simopt.solvers.strong

STRONG Solver.

STRONG: A trust-region-based algorithm that fits first- or second-order models through function evaluations taken within a neighborhood of the incumbent solution. A detailed description of the solver can be found here.

Module Contents

class simopt.solvers.strong.STRONGConfig

Bases: simopt.base.SolverConfig

Configuration for STRONG solver.

n0: Annotated[int, Field(default=10, gt=0, description='initial sample size')]
n_r: Annotated[int, Field(default=10, gt=0, description='number of replications taken at each solution')]
sensitivity: Annotated[float, Field(default=1e-07, gt=0, description='shrinking scale for VarBds')]
delta_threshold: Annotated[float, Field(default=1.2, gt=0, description='maximum value of the radius')]
delta_t: Annotated[float, Field(default=2.0, description='initial size of trust region', alias='delta_T')]
eta_0: Annotated[float, Field(default=0.01, gt=0, lt=1, description='constant for accepting')]
eta_1: Annotated[float, Field(default=0.3, lt=1, description='constant for more confident accepting')]
gamma_1: Annotated[float, Field(default=0.9, gt=0, lt=1, description='constant for shrinking the trust region')]
gamma_2: Annotated[float, Field(default=1.11, gt=1, description='constant for expanding the trust region')]
lambda_: Annotated[int, Field(default=2, gt=1, alias='lambda', description='magnifying factor for n_r in finite difference function')]
lambda_2: Annotated[float, Field(default=1.01, gt=1, description='magnifying factor for n_r in stage I and stage II (>1)')]
class simopt.solvers.strong.STRONG(name: str = '', fixed_factors: dict | None = None)

Bases: simopt.base.Solver

STRONG Solver.

A trust-region-based algorithm that fits first- or second-order models through function evaluations taken within a neighborhood of the incumbent solution.

Initialize a solver object.

Parameters:

  • name (str, optional) – Name of the solver. Defaults to an empty string.

  • fixed_factors (dict | None, optional) – Dictionary of user-specified solver factors. Defaults to None.

name: str = 'STRONG'
config_class: ClassVar[type[simopt.base.SolverConfig]]

Configuration class for the solver.

class_name_abbr: ClassVar[str] = 'STRONG'

Short name of the solver class.

class_name: ClassVar[str] = 'STRONG'

Long name of the solver class.

objective_type: ClassVar[simopt.base.ObjectiveType]

Description of objective types.

constraint_type: ClassVar[simopt.base.ConstraintType]

Description of constraint types.

variable_type: ClassVar[simopt.base.VariableType]

Description of variable types.

gradient_needed: ClassVar[bool] = False

True if gradient of objective function is needed, otherwise False.

solve(problem: simopt.base.Problem) → None

Run a single macroreplication of a solver on a problem.

Parameters:

problem (Problem) – Simulation-optimization problem to solve.

Returns:

  • list [Solution]: List of solutions recommended throughout the budget.

  • list [int]: List of intermediate budgets when recommended solutions

    change.

Return type:

tuple

cauchy_point(grad: numpy.ndarray, hessian: numpy.ndarray, new_x: numpy.ndarray, problem: simopt.base.Problem) → numpy.ndarray

Find the Cauchy point based on the gradient and Hessian matrix.

check_cons(candidate_x: tuple, new_x: tuple | numpy.ndarray, lower_bound: tuple, upper_bound: tuple) → numpy.ndarray

Check feasibility of a new point and apply Cauchy point correction if needed.

This method compares a candidate point to its updated version and enforces box constraints defined by lower and upper bounds.

Parameters:

  • candidate_x (tuple) – Current decision variable vector (the Cauchy point).

  • new_x (tuple | np.ndarray) – Proposed new solution to check and correct.

  • lower_bound (tuple) – Lower bounds for each decision variable.

  • upper_bound (tuple) – Upper bounds for each decision variable.

Returns:

The corrected feasible solution, clipped to respect the bounds.

Return type:

np.ndarray