simopt.models.sscont ==================== .. py:module:: simopt.models.sscont .. autoapi-nested-parse:: Simulate sales for a (s,S) inventory problem with continuous inventory. Module Contents --------------- .. py:class:: SSContConfig Bases: :py:obj:`pydantic.BaseModel` Configuration for the (s, S) continuous inventory model. .. py:attribute:: demand_mean :type: Annotated[float, Field(default=100.0, description='mean of exponentially distributed demand in each period', gt=0)] .. py:attribute:: lead_mean :type: Annotated[float, Field(default=6.0, description='mean of Poisson distributed order lead time', gt=0)] .. py:attribute:: backorder_cost :type: Annotated[float, Field(default=4.0, description='cost per unit of demand not met with in-stock inventory', gt=0)] .. py:attribute:: holding_cost :type: Annotated[float, Field(default=1.0, description='holding cost per unit per period', gt=0)] .. py:attribute:: fixed_cost :type: Annotated[float, Field(default=36.0, description='order fixed cost', gt=0)] .. py:attribute:: variable_cost :type: Annotated[float, Field(default=2.0, description='order variable cost per unit', gt=0)] .. py:attribute:: s :type: Annotated[float, Field(default=1000.0, description='inventory threshold for placing order', gt=0)] .. py:attribute:: S :type: Annotated[float, Field(default=2000.0, description='max inventory', gt=0)] .. py:attribute:: n_days :type: Annotated[int, Field(default=100, description='number of periods to simulate', ge=1, json_schema_extra={'isDatafarmable': False})] .. py:attribute:: warmup :type: Annotated[int, Field(default=20, description='number of periods as warmup before collecting statistics', ge=0, json_schema_extra={'isDatafarmable': False})] .. py:class:: SSContMinCostConfig Bases: :py:obj:`pydantic.BaseModel` Configuration model for SSCont Min Cost Problem. Min Total Cost for (s, S) Inventory simulation-optimization problem. .. py:attribute:: initial_solution :type: Annotated[tuple[float, Ellipsis], Field(default=(600, 600), description='initial solution from which solvers start')] .. py:attribute:: budget :type: Annotated[int, Field(default=1000, description='max # of replications for a solver to take', gt=0, json_schema_extra={'isDatafarmable': False})] .. py:class:: SSCont(fixed_factors: dict | None = None) Bases: :py:obj:`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. :param fixed_factors: Fixed factors of the simulation model. Defaults to None. :type fixed_factors: dict, optional .. py:attribute:: class_name_abbr :type: ClassVar[str] :value: 'SSCONT' Short name of the model class. .. py:attribute:: class_name :type: ClassVar[str] :value: '(s, S) Inventory' Long name of the model class. .. py:attribute:: config_class :type: ClassVar[type[pydantic.BaseModel]] Configuration class for the model. .. py:attribute:: n_rngs :type: ClassVar[int] :value: 2 Number of RNGs used to run a simulation replication. .. py:attribute:: n_responses :type: ClassVar[int] :value: 7 Number of responses (performance measures). .. py:attribute:: demand_model .. py:attribute:: lead_model .. py:method:: before_replicate(rng_list: list[mrg32k3a.mrg32k3a.MRG32k3a]) -> None Prepare the model just before generating a replication. :param rng_list: RNGs used to drive the simulation. :type rng_list: list[MRG32k3a] :raises NotImplementedError: If the subclass does not implement this hook. .. py:method:: replicate() -> tuple[dict, dict] Simulate a single replication for the current model factors. :param rng_list: Random number generators used to simulate the replication. :type rng_list: list[MRG32k3a] :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. :rtype: tuple[dict, dict] .. py:class:: SSContMinCost(name: str = '', fixed_factors: dict | None = None, model_fixed_factors: dict | None = None) Bases: :py:obj:`simopt.base.Problem` Class to make (s,S) inventory simulation-optimization problems. Initialize a problem object. :param name: Name of the problem. :type name: str :param fixed_factors: Dictionary of user-specified problem factors. :type fixed_factors: dict | None :param model_fixed_factors: Subset of user-specified non-decision factors passed to the model. :type model_fixed_factors: dict | None .. py:attribute:: class_name_abbr :type: ClassVar[str] :value: 'SSCONT-1' Short name of the problem class. .. py:attribute:: class_name :type: ClassVar[str] :value: 'Min Total Cost for (s, S) Inventory' Long name of the problem class. .. py:attribute:: config_class :type: ClassVar[type[pydantic.BaseModel]] Configuration class for problem. .. py:attribute:: model_class :type: ClassVar[type[simopt.base.Model]] Simulation model class for problem. .. py:attribute:: n_objectives :type: ClassVar[int] :value: 1 Number of objectives. .. py:attribute:: n_stochastic_constraints :type: ClassVar[int] :value: 0 Number of stochastic constraints. .. py:attribute:: minmax :type: ClassVar[tuple[int, Ellipsis]] Indicators of maximization (+1) or minimization (-1) for each objective. .. py:attribute:: constraint_type :type: ClassVar[simopt.base.ConstraintType] Description of constraints types. .. py:attribute:: variable_type :type: ClassVar[simopt.base.VariableType] Description of variable types. .. py:attribute:: gradient_available :type: ClassVar[bool] :value: False Indicates whether the solver provides direct gradient information. .. py:attribute:: optimal_value :type: ClassVar[float | None] :value: None Optimal objective function value (if known). .. py:attribute:: optimal_solution :type: tuple | None :value: None Optimal solution if known; defaults to None. .. py:attribute:: model_default_factors :type: ClassVar[dict] Default values for overriding model-level default factors. .. py:attribute:: model_decision_factors :type: ClassVar[set[str]] Set of keys for factors that are decision variables. .. py:property:: dim :type: int Number of decision variables. .. py:property:: lower_bounds :type: tuple Lower bound for each decision variable. .. py:property:: upper_bounds :type: tuple Upper bound for each decision variable. .. py:method:: vector_to_factor_dict(vector: tuple) -> dict Convert a vector of variables to a dictionary with factor keys. :param vector: A vector of values associated with decision variables. :type vector: tuple :returns: Dictionary with factor keys and associated values. :rtype: dict .. py:method:: factor_dict_to_vector(factor_dict: dict) -> tuple Convert a dictionary with factor keys to a vector of variables. :param factor_dict: Dictionary with factor keys and associated values. :type factor_dict: dict :returns: Vector of values associated with decision variables. :rtype: tuple .. py:method:: replicate(_x: tuple) -> simopt.base.RepResult Replicate the problem for a given solution. :param x: The solution to evaluate. :type x: tuple .. py:method:: check_deterministic_constraints(x: tuple) -> bool Check if a solution `x` satisfies the problem's deterministic constraints. :param x: A vector of decision variables. :type x: tuple :returns: True if the solution satisfies all deterministic constraints; False otherwise. :rtype: bool .. py:method:: get_random_solution(rand_sol_rng: mrg32k3a.mrg32k3a.MRG32k3a) -> tuple Generate a random solution for starting or restarting solvers. :param rand_sol_rng: Random number generator used to sample the solution. :type rand_sol_rng: MRG32k3a :returns: A tuple representing a randomly generated vector of decision variables. :rtype: tuple