simopt.models.sscont

Simulate sales for a (s,S) inventory problem with continuous inventory.

Module Contents

class simopt.models.sscont.SSContConfig

Bases: pydantic.BaseModel

Configuration for the (s, S) continuous inventory model.

demand_mean: Annotated[float, Field(default=100.0, description='mean of exponentially distributed demand in each period', gt=0)]

lead_mean: Annotated[float, Field(default=6.0, description='mean of Poisson distributed order lead time', gt=0)]

backorder_cost: Annotated[float, Field(default=4.0, description='cost per unit of demand not met with in-stock inventory', gt=0)]

holding_cost: Annotated[float, Field(default=1.0, description='holding cost per unit per period', gt=0)]

fixed_cost: Annotated[float, Field(default=36.0, description='order fixed cost', gt=0)]

variable_cost: Annotated[float, Field(default=2.0, description='order variable cost per unit', gt=0)]

s: Annotated[float, Field(default=1000.0, description='inventory threshold for placing order', gt=0)]

S: Annotated[float, Field(default=2000.0, description='max inventory', gt=0)]

n_days: Annotated[int, Field(default=100, description='number of periods to simulate', ge=1, json_schema_extra={'isDatafarmable': False})]

warmup: Annotated[int, Field(default=20, description='number of periods as warmup before collecting statistics', ge=0, json_schema_extra={'isDatafarmable': False})]

class simopt.models.sscont.SSContMinCostConfig

Bases: pydantic.BaseModel

Configuration model for SSCont Min Cost Problem.

Min Total Cost for (s, S) Inventory simulation-optimization problem.

initial_solution: Annotated[tuple[float, Ellipsis], Field(default=600, 600, description='initial solution from which solvers start')]

budget: Annotated[int, Field(default=1000, description='max # of replications for a solver to take', gt=0, json_schema_extra={'isDatafarmable': False})]

class simopt.models.sscont.SSCont(fixed_factors: dict | None = None)

Bases: simopt.base.Model

(s,S) Inventory Simulation Model.

A model that simulates multiple periods’ worth of sales for a (s,S) inventory problem with continuous inventory, exponentially distributed demand, and poisson distributed lead time. Returns the various types of average costs per period, order rate, stockout rate, fraction of demand met with inventory on hand, average amount backordered given a stockout occured, and average amount ordered given an order occured.

Initialize the (s,S) inventory simulation model.

Parameters:

fixed_factors (dict, optional) – Fixed factors of the simulation model. Defaults to None.

class_name_abbr: ClassVar[str] = 'SSCONT'

Short name of the model class.

class_name: ClassVar[str] = '(s, S) Inventory'

Long name of the model class.

config_class: ClassVar[type[pydantic.BaseModel]]

Configuration class for the model.

n_rngs: ClassVar[int] = 2

Number of RNGs used to run a simulation replication.

n_responses: ClassVar[int] = 7

Number of responses (performance measures).

demand_model

lead_model

before_replicate(rng_list: list[mrg32k3a.mrg32k3a.MRG32k3a]) → None

Prepare the model just before generating a replication.

Parameters:

rng_list (list[MRG32k3a]) – RNGs used to drive the simulation.

Raises:

NotImplementedError – If the subclass does not implement this hook.

replicate() → tuple[dict, dict]

Simulate a single replication for the current model factors.

Parameters:

rng_list (list[MRG32k3a]) – Random number generators used to simulate the replication.

Returns:

A tuple containing:

• responses (dict): Performance measures of interest, including:

  • ”avg_backorder_costs”: Average backorder costs per period.

  • ”avg_order_costs”: Average order costs per period.

  • ”avg_holding_costs”: Average holding costs per period.

  • ”on_time_rate”: Fraction of demand met with stock on hand

    in store.

  • ”order_rate”: Fraction of periods in which an order was made.

  • ”stockout_rate”: Fraction of periods with a stockout.

  • ”avg_stockout”: Mean amount of product backordered given a

    stockout occurred.

  • ”avg_order”: Mean amount of product ordered given an

    order occurred.

• gradients (dict): A dictionary of gradient estimates for

  each response.

Return type:

tuple[dict, dict]

class simopt.models.sscont.SSContMinCost(name: str = '', fixed_factors: dict | None = None, model_fixed_factors: dict | None = None)

Bases: simopt.base.Problem

Class to make (s,S) inventory simulation-optimization problems.

Initialize a problem object.

Parameters:

• name (str) – Name of the problem.

• fixed_factors (dict | None) – Dictionary of user-specified problem factors.

• model_fixed_factors (dict | None) – Subset of user-specified non-decision factors passed to the model.

class_name_abbr: ClassVar[str] = 'SSCONT-1'

Short name of the problem class.

class_name: ClassVar[str] = 'Min Total Cost for (s, S) Inventory'

Long name of the problem class.

config_class: ClassVar[type[pydantic.BaseModel]]

Configuration class for problem.

model_class: ClassVar[type[simopt.base.Model]]

Simulation model class for problem.

n_objectives: ClassVar[int] = 1

Number of objectives.

n_stochastic_constraints: ClassVar[int] = 0

Number of stochastic constraints.

minmax: ClassVar[tuple[int, Ellipsis]]

Indicators of maximization (+1) or minimization (-1) for each objective.

constraint_type: ClassVar[simopt.base.ConstraintType]

Description of constraints types.

variable_type: ClassVar[simopt.base.VariableType]

Description of variable types.

gradient_available: ClassVar[bool] = False

Indicates whether the solver provides direct gradient information.

optimal_value: ClassVar[float | None] = None

Optimal objective function value (if known).

optimal_solution: tuple | None = None

Optimal solution if known; defaults to None.

model_default_factors: ClassVar[dict]

Default values for overriding model-level default factors.

model_decision_factors: ClassVar[set[str]]

Set of keys for factors that are decision variables.

property dim: int

Number of decision variables.

property lower_bounds: tuple

Lower bound for each decision variable.

property upper_bounds: tuple

Upper bound for each decision variable.

vector_to_factor_dict(vector: tuple) → dict

Convert a vector of variables to a dictionary with factor keys.

Parameters:

vector (tuple) – A vector of values associated with decision variables.

Returns:

Dictionary with factor keys and associated values.

Return type:

dict

factor_dict_to_vector(factor_dict: dict) → tuple

Convert a dictionary with factor keys to a vector of variables.

Parameters:

factor_dict (dict) – Dictionary with factor keys and associated values.

Returns:

Vector of values associated with decision variables.

Return type:

tuple

replicate(_x: tuple) → simopt.base.RepResult

Replicate the problem for a given solution.

Parameters:

x (tuple) – The solution to evaluate.

check_deterministic_constraints(x: tuple) → bool

Check if a solution x satisfies the problem’s deterministic constraints.

Parameters:

x (tuple) – A vector of decision variables.

Returns:

True if the solution satisfies all deterministic constraints;

False otherwise.

Return type:

bool

get_random_solution(rand_sol_rng: mrg32k3a.mrg32k3a.MRG32k3a) → tuple

Generate a random solution for starting or restarting solvers.

Parameters:

rand_sol_rng (MRG32k3a) – Random number generator used to sample the solution.

Returns:

A tuple representing a randomly generated vector of decision

variables.

Return type:

tuple