simopt.models package<a class="headerlink" href="#simopt-models-package" title="Permalink to this heading">¶

check_arrival_gammas()¶

check_depart_probabilities()¶

check_erlang_scale()¶

check_erlang_shape()¶

check_number_attractions()¶

check_park_capacity()¶

check_queue_capacities()¶

check_simulatable_factors()¶

Determine if a simulation replication can be run with the given factors.

Notes

Each subclass of base.Model has its own custom check_simulatable_factors method.

Returns: is_simulatable – True if model specified by factors is simulatable, otherwise False.
Return type: bool

check_time_open()¶

check_transition_probabilities()¶

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters

rng_list ([list] [rng.mrg32k3a.MRG32k3a]) – rngs for model to use when simulating a replication

Returns

responses – performance measures of interest “total_departed_tourists”: The total number of tourists to leave the park due

to full queues

”percent_departed_tourists”: The percentage of tourists to leave the park due: to full queues

Return type

class simopt.models.amusementpark.AmusementParkMinDepart(name='AMUSEMENTPARK-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Class to make amusement park simulation-optimization problems.

name¶

name of problem

Type: str

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: str

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: str

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: base.Model

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: [list] [rng.mrg32k3a.MRG32k3a]

factors¶

changeable factors of the problem

initial_solutiontuple: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name of problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dict) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (rng.mrg32k3a.MRG32k3a) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dict) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dict) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dict

simopt.models.chessmm module¶

Summary¶

Simulate matching of chess players on an online platform. A detailed description of the model/problem can be found here.

class simopt.models.chessmm.ChessAvgDifference(name='CHESS-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Base class to implement simulation-optimization problems.

name¶

name of problem

Type: string

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: string

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: string

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: Model object

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: list of mrg32k3a.mrg32k3a.MRG32k3a objects

factors¶

changeable factors of the problem

initial_solutionlist: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take
prev_costlist: cost of prevention
upper_thresfloat > 0: upper limit of amount of contamination

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name for problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

check_upper_time()¶

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dictionary) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a object) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dictionary

class simopt.models.chessmm.ChessMatchmaking(fixed_factors=None)¶

Bases: Model

A model that simulates a matchmaking problem with a Elo (truncated normal) distribution of players and Poisson arrivals. Returns the average difference between matched players.

name¶

name of model

Type: string

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI and data validation)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters: fixed_factors (nested dict) – fixed factors of the simulation model

See also

check_allowable_diff()¶

check_elo_mean()¶

check_elo_sd()¶

check_num_players()¶

check_poisson_rate()¶

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters

rng_list (list of mrg32k3a.mrg32k3a.MRG32k3a objects) – rngs for model to use when simulating a replication

Returns

responses (dict) – performance measures of interest “avg_diff” = the average Elo difference between all pairs “avg_wait_time” = the average waiting time
gradients (dict of dicts) – gradient estimates for each response

simopt.models.cntnv module¶

Summary¶

Simulate a day’s worth of sales for a newsvendor. A detailed description of the model/problem can be found here.

class simopt.models.cntnv.CntNV(fixed_factors=None)¶

Bases: Model

A model that simulates a day’s worth of sales for a newsvendor with a Burr Type XII demand distribution. Returns the profit, after accounting for order costs and salvage.

name¶

name of model

Type: string

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters: fixed_factors (dict) – fixed_factors of the simulation model

See also

check_Burr_c()¶

check_Burr_k()¶

check_order_quantity()¶

check_purchase_price()¶

check_sales_price()¶

check_salvage_price()¶

check_simulatable_factors()¶

Determine if a simulation replication can be run with the given factors.

Notes

Each subclass of base.Model has its own custom check_simulatable_factors method.

Returns: is_simulatable – True if model specified by factors is simulatable, otherwise False.
Return type: bool

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters: rng_list (list of mrg32k3a.mrg32k3a.MRG32k3a objects) – rngs for model to use when simulating a replication
Returns: responses – performance measures of interest “profit” = profit in this scenario “stockout_qty” = amount by which demand exceeded supply “stockout” = was there unmet demand? (Y/N)
Return type: dict

class simopt.models.cntnv.CntNVMaxProfit(name='CNTNEWS-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Base class to implement simulation-optimization problems.

name¶

name of problem

Type: string

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: string

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: string

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: Model object

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: list of mrg32k3a.mrg32k3a.MRG32k3a objects

factors¶

changeable factors of the problem

initial_solutiontuple: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name for problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dictionary) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a object) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dictionary

simopt.models.contam module¶

Summary¶

Simulate contamination rates. A detailed description of the model/problem can be found here.

class simopt.models.contam.Contamination(fixed_factors=None)¶

Bases: Model

A model that simulates a contamination problem with a beta distribution. Returns the probability of violating contamination upper limit in each level of supply chain.

name¶

name of model

Type: string

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI and data validation)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters: fixed_factors (nested dict) – fixed factors of the simulation model

See also

check_contam_rate_alpha()¶

check_contam_rate_beta()¶

check_initial_rate_alpha()¶

check_initial_rate_beta()¶

check_prev_cost()¶

check_prev_decision()¶

check_restore_rate_alpha()¶

check_restore_rate_beta()¶

check_simulatable_factors()¶

Determine if a simulation replication can be run with the given factors.

Notes

Each subclass of base.Model has its own custom check_simulatable_factors method.

Returns: is_simulatable – True if model specified by factors is simulatable, otherwise False.
Return type: bool

check_stages()¶

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters

rng_list (list of mrg32k3a.mrg32k3a.MRG32k3a objects) – rngs for model to use when simulating a replication

Returns

responses (dict) – performance measures of interest “level” = a list of contamination levels over time
gradients (dict of dicts) – gradient estimates for each response

class simopt.models.contam.ContaminationTotalCostCont(name='CONTAM-2', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Base class to implement simulation-optimization problems.

name¶

name of problem

Type: string

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: string

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: string

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: Model object

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: list of mrg32k3a.mrg32k3a.MRG32k3a objects

factors¶

changeable factors of the problem

initial_solutionlist: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take
prev_costlist: cost of prevention
upper_thresfloat > 0: upper limit of amount of contamination

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name for problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_budget()¶

Check if budget is strictly positive.

Returns: True if budget is strictly positive, otherwise False.
Return type: bool

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

check_error_prob()¶

check_initial_solution()¶

Check if initial solution is feasible and of correct dimension.

Returns: True if initial solution is feasible and of correct dimension, otherwise False.
Return type: bool

check_prev_cost()¶

check_simulatable_factors()¶

check_upper_thres()¶

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dictionary) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

factor_dict_to_vector_gradients(factor_dict)¶

Convert a dictionary with factor keys to a gradient vector.

Notes

A subclass of base.Problem can have its own custom factor_dict_to_vector_gradients method if the objective is deterministic.

Parameters: factor_dict (dict) – Dictionary with factor keys and associated values.
Returns: vector – Vector of partial derivatives associated with decision variables.
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a object) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_objectives_gradients(response_dict)¶

Convert a dictionary with response keys to a vector of gradients.

Notes

A subclass of base.Problem can have its own custom response_dict_to_objectives_gradients method if the objective is deterministic.

Parameters: response_dict (dict) – Dictionary with response keys and associated values.
Returns: Vector of gradients.
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dictionary

class simopt.models.contam.ContaminationTotalCostDisc(name='CONTAM-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Base class to implement simulation-optimization problems.

name¶

name of problem

Type: string

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: string

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: string

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: float

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: Model object

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: list of mrg32k3a.mrg32k3a.MRG32k3a objects

factors¶

changeable factors of the problem

initial_solutionlist: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take
prev_costlist: cost of prevention
upper_thresfloat > 0: upper limit of amount of contamination

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name for problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

check_error_prob()¶

check_prev_cost()¶

check_upper_thres()¶

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dictionary) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

factor_dict_to_vector_gradients(factor_dict)¶

Convert a dictionary with factor keys to a gradient vector.

Notes

A subclass of base.Problem can have its own custom factor_dict_to_vector_gradients method if the objective is deterministic.

Parameters: factor_dict (dict) – Dictionary with factor keys and associated values.
Returns: vector – Vector of partial derivatives associated with decision variables.
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a object) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_objectives_gradients(response_dict)¶

Convert a dictionary with response keys to a vector of gradients.

Notes

A subclass of base.Problem can have its own custom response_dict_to_objectives_gradients method if the objective is deterministic.

Parameters: response_dict (dict) – Dictionary with response keys and associated values.
Returns: Vector of gradients.
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dictionary

simopt.models.dualsourcing module¶

Summary¶

Simulate multiple periods of ordering and sales for a dual sourcing inventory problem. A detailed description of the model/problem can be found here.

class simopt.models.dualsourcing.DualSourcing(fixed_factors=None)¶

Bases: Model

A model that simulates multiple periods of ordering and sales for a single-staged, dual sourcing inventory problem with stochastic demand. Returns average holding cost, average penalty cost, and average ordering cost per period.

name¶

name of model

Type: str

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters

fixed_factors (dict) –

fixed_factors of the simulation model

n_days: Number of days to simulate (int)
initial_inv: Initial inventory (int)
cost_reg: Regular ordering cost per unit (flt)
cost_exp: Expedited ordering cost per unit (flt)
lead_reg: Lead time for regular orders in days (int)
lead_exp: Lead time for expedited orders in days (int)
holding_cost: Holding cost per unit per period (flt)
penalty_cost: Penalty cost per unit per period for backlogging(flt)
st_dev: Standard deviation of demand distribution (flt)
mu: Mean of demand distribution (flt)
order_level_reg: Order-up-to level for regular orders (int)
order_level_exp: Order-up-to level for expedited orders (int)

See also

check_cost_exp()¶

check_cost_reg()¶

check_holding_cost()¶

check_initial_inv()¶

check_lead_exp()¶

check_lead_reg()¶

check_mu()¶

check_n_days()¶

check_order_level_exp()¶

check_order_level_reg()¶

check_penalty_cost()¶

check_simulatable_factors()¶

Determine if a simulation replication can be run with the given factors.

Notes

Each subclass of base.Model has its own custom check_simulatable_factors method.

Returns: is_simulatable – True if model specified by factors is simulatable, otherwise False.
Return type: bool

check_st_dev()¶

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters

rng_list ([list] [mrg32k3a.mrg32k3a.MRG32k3a]) – rngs for model to use when simulating a replication

Returns

responses – performance measures of interest

average_holding_cost: The average holding cost over the time period
average_penalty_cost: The average penalty cost over the time period
average_ordering_cost: The average ordering cost over the time period

Return type

class simopt.models.dualsourcing.DualSourcingMinCost(name='DUALSOURCING-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Class to make dual-sourcing inventory simulation-optimization problems.

name¶

name of problem

Type: str

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: str

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: str

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: base.Model

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: [list] [mrg32k3a.mrg32k3a.MRG32k3a]

factors¶

changeable factors of the problem

initial_solutiontuple: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name of problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dict) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dict) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dict) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

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

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dict

simopt.models.dynamnews module¶

Summary¶

Simulate a day’s worth of sales for a newsvendor under dynamic consumer substitution. A detailed description of the model/problem can be found here.

class simopt.models.dynamnews.DynamNews(fixed_factors=None)¶

Bases: Model

A model that simulates a day’s worth of sales for a newsvendor with dynamic consumer substitution. Returns the profit and the number of products that stock out.

name¶

name of model

Type: string

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters: fixed_factors (dict) – fixed_factors of the simulation model

See also

check_c_utility()¶

check_cost()¶

check_init_level()¶

check_mu()¶

check_num_customer()¶

check_num_prod()¶

check_price()¶

check_simulatable_factors()¶

Determine if a simulation replication can be run with the given factors.

Notes

Each subclass of base.Model has its own custom check_simulatable_factors method.

Returns: is_simulatable – True if model specified by factors is simulatable, otherwise False.
Return type: bool

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters: rng_list (list of mrg32k3a.mrg32k3a.MRG32k3a objects) – rngs for model to use when simulating a replication
Returns: responses – performance measures of interest “profit” = profit in this scenario “n_prod_stockout” = number of products which are out of stock
Return type: dict

class simopt.models.dynamnews.DynamNewsMaxProfit(name='DYNAMNEWS-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Base class to implement simulation-optimization problems.

name¶

name of problem

Type: string

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: string

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: string

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: Model object

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: list of mrg32k3a.mrg32k3a.MRG32k3a objects

factors¶

changeable factors of the problem

initial_solutiontuple: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name for problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dictionary) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a object) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dictionary

simopt.models.example module¶

Summary¶

Simulate a synthetic problem with a deterministic objective function evaluated with noise.

class simopt.models.example.ExampleModel(fixed_factors=None)¶

Bases: Model

A model that is a deterministic function evaluated with noise.

name¶

name of model

Type: string

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters: fixed_factors (dict) – fixed_factors of the simulation model

See also

check_simulatable_factors()¶

Determine if a simulation replication can be run with the given factors.

Notes

Each subclass of base.Model has its own custom check_simulatable_factors method.

Returns: is_simulatable – True if model specified by factors is simulatable, otherwise False.
Return type: bool

check_x()¶

replicate(rng_list)¶

Evaluate a deterministic function f(x) with stochastic noise.

Parameters: rng_list (list of mrg32k3a.mrg32k3a.MRG32k3a objects) – rngs for model to use when simulating a replication
Returns: responses – performance measures of interest “est_f(x)” = f(x) evaluated with stochastic noise
Return type: dict

class simopt.models.example.ExampleProblem(name='EXAMPLE-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Base class to implement simulation-optimization problems.

name¶

name of problem

Type: string

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: string

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: string

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: Model object

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: list of mrg32k3a.mrg32k3a.MRG32k3a objects

factors¶

changeable factors of the problem

initial_solutiontuple: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name for problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dictionary) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a object) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dictionary

simopt.models.facilitysizing module¶

Summary¶

Simulate demand at facilities. A detailed description of the model/problem can be found here.

class simopt.models.facilitysizing.FacilitySize(fixed_factors=None)¶

Bases: Model

A model that simulates a facilitysize problem with a multi-variate normal distribution. Returns the probability of violating demand in each scenario.

name¶

name of model

Type: string

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI and data validation)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters: fixed_factors (nested dict) – fixed factors of the simulation model

See also

check_capacity()¶

check_cov()¶

check_mean_vec()¶

check_n_fac()¶

check_simulatable_factors()¶

Determine if a simulation replication can be run with the given factors.

Notes

Each subclass of base.Model has its own custom check_simulatable_factors method.

Returns: is_simulatable – True if model specified by factors is simulatable, otherwise False.
Return type: bool

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters

rng_list (list of mrg32k3a.mrg32k3a.MRG32k3a objects) – rngs for model to use when simulating a replication

Returns

responses (dict) – performance measures of interest “stockout_flag” = a binary variable

0 : all facilities satisfy the demand 1 : at least one of the facilities did not satisfy the demand

”n_fac_stockout” = the number of facilities which cannot satisfy the demand “n_cut” = the number of toal demand which cannot be satisfied
gradients (dict of dicts) – gradient estimates for each response

class simopt.models.facilitysizing.FacilitySizingMaxService(name='FACSIZE-2', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Base class to implement simulation-optimization problems.

name¶

name of problem

Type: string

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: string

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: string

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: Model object

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: list of mrg32k3a.mrg32k3a.MRG32k3a objects

factors¶

changeable factors of the problem

initial_solutiontuple: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name for problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

check_installation_budget()¶

check_installation_costs()¶

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dictionary) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a object) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dictionary

class simopt.models.facilitysizing.FacilitySizingTotalCost(name='FACSIZE-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Base class to implement simulation-optimization problems.

name¶

name of problem

Type: string

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: string

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: string

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: float

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: Model object

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: list of mrg32k3a.mrg32k3a.MRG32k3a objects

factors¶

changeable factors of the problem

initial_solutiontuple: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name for problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

check_epsilon()¶

check_installation_costs()¶

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dictionary) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

factor_dict_to_vector_gradients(factor_dict)¶

Convert a dictionary with factor keys to a gradient vector.

Notes

A subclass of base.Problem can have its own custom factor_dict_to_vector_gradients method if the objective is deterministic.

Parameters: factor_dict (dict) – Dictionary with factor keys and associated values.
Returns: vector – Vector of partial derivatives associated with decision variables.
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a object) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_objectives_gradients(response_dict)¶

Convert a dictionary with response keys to a vector of gradients.

Notes

A subclass of base.Problem can have its own custom response_dict_to_objectives_gradients method if the objective is deterministic.

Parameters: response_dict (dict) – Dictionary with response keys and associated values.
Returns: Vector of gradients.
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dictionary

simopt.models.fixedsan module¶

Summary¶

Simulate duration of a stochastic activity network (SAN). A detailed description of the model/problem can be found here.

class simopt.models.fixedsan.FixedSAN(fixed_factors=None)¶

Bases: Model

A model that simulates a stochastic activity network problem with tasks that have exponentially distributed durations, and the selected means come with a cost.

name¶

name of model

Type: string

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI and data validation)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters: fixed_factors (nested dict) – fixed factors of the simulation model

See also

check_arc_means()¶

check_num_arcs()¶

check_num_nodes()¶

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters

rng_list (list of mrg32k3a.mrg32k3a.MRG32k3a objects) – rngs for model to use when simulating a replication

Returns

responses (dict) – performance measures of interest “longest_path_length” = length/duration of longest path
gradients (dict of dicts) – gradient estimates for each response

class simopt.models.fixedsan.FixedSANLongestPath(name='FIXEDSAN-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Base class to implement simulation-optimization problems.

name¶

name of problem

Type: string

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: string

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: string

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: Model object

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: list of mrg32k3a.mrg32k3a.MRG32k3a objects

factors¶

changeable factors of the problem

initial_solutionlist: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name for problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_arc_costs()¶

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dictionary) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a object) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dictionary

simopt.models.hotel module¶

Summary¶

Simulate expected revenue for a hotel. A detailed description of the model/problem can be found here.

class simopt.models.hotel.Hotel(fixed_factors=None)¶

Bases: Model

A model that simulates business of a hotel with Poisson arrival rate.

name¶

name of model

Type: string

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI and data validation)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters: fixed_factors (nested dict) – fixed factors of the simulation model

See also

check_booking_limits()¶

check_discount_rate()¶

check_lambda()¶

check_num_products()¶

check_num_rooms()¶

check_product_incidence()¶

check_rack_rate()¶

check_runlength()¶

check_time_before()¶

check_time_limit()¶

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters

rng_list (list of mrg32k3a.mrg32k3a.MRG32k3a objects) – rngs for model to use when simulating a replication

Returns

responses (dict) – performance measures of interest “revenue” = expected revenue
gradients (dict of dicts) – gradient estimates for each response

class simopt.models.hotel.HotelRevenue(name='HOTEL-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Base class to implement simulation-optimization problems.

name¶

name of problem

Type: string

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: string

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: string

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: Model object

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: list of mrg32k3a.mrg32k3a.MRG32k3a objects

factors¶

changeable factors of the problem

initial_solutionlist: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name for problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_budget()¶

Check if budget is strictly positive.

Returns: True if budget is strictly positive, otherwise False.
Return type: bool

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

check_initial_solution()¶

Check if initial solution is feasible and of correct dimension.

Returns: True if initial solution is feasible and of correct dimension, otherwise False.
Return type: bool

check_simulatable_factors()¶

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dictionary) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a object) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dictionary

simopt.models.ironore module¶

Summary¶

Simulate multiple periods of production and sales for an iron ore inventory problem. A detailed description of the model/problem can be found here.

Changed get_random_solution quantiles: from 10 and 200 => mean=59.887, sd=53.338, p(X>100)=0.146 to 10 and 1000 => mean=199.384, sd=343.925, p(X>100)=0.5

class simopt.models.ironore.IronOre(fixed_factors=None)¶

Bases: Model

A model that simulates multiple periods of production and sales for an inventory problem with stochastic price determined by a mean-reverting random walk. Returns total profit, fraction of days producing iron, and mean stock.

name¶

name of model

Type: str

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters: fixed_factors (dict) – fixed_factors of the simulation model

See also

check_capacity()¶

check_holding_cost()¶

check_inven_stop()¶

check_max_price()¶

check_max_prod_perday()¶

check_mean_price()¶

check_min_price()¶

check_n_days()¶

check_price_prod()¶

check_price_sell()¶

check_price_stop()¶

check_prod_cost()¶

check_simulatable_factors()¶

Determine if a simulation replication can be run with the given factors.

Notes

Each subclass of base.Model has its own custom check_simulatable_factors method.

Returns: is_simulatable – True if model specified by factors is simulatable, otherwise False.
Return type: bool

check_st_dev()¶

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters: rng_list ([list] [mrg32k3a.mrg32k3a.MRG32k3a]) – rngs for model to use when simulating a replication
Returns: responses – performance measures of interest “total_profit” = The total profit over the time period “frac_producing” = The fraction of days spent producing iron ore “mean_stock” = The average stocks over the time period
Return type: dict

class simopt.models.ironore.IronOreMaxRev(name='IRONORE-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Class to make iron ore inventory simulation-optimization problems.

name¶

name of problem

Type: str

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: str

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: str

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: float

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: base.Model

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: [list] [mrg32k3a.mrg32k3a.MRG32k3a]

factors¶

changeable factors of the problem

initial_solutiontuple: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name of problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dict) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dict) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dict) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dict

class simopt.models.ironore.IronOreMaxRevCnt(name='IRONORECONT-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Class to make iron ore inventory simulation-optimization problems.

name¶

name of problem

Type: str

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: str

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: str

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: base.Model

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: [list] [mrg32k3a.mrg32k3a.MRG32k3a]

factors¶

changeable factors of the problem

initial_solutiontuple: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name of problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dict) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dict) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dict) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dict

simopt.models.mm1queue module¶

Summary¶

Simulate a M/M/1 queue. A detailed description of the model/problem can be found here.

class simopt.models.mm1queue.MM1MinMeanSojournTime(name='MM1-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Base class to implement simulation-optimization problems.

name¶

name of problem

Type: string

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: string

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: string

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: Model object

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: list of mrg32k3a.mrg32k3a.MRG32k3a objects

factors¶

changeable factors of the problem

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name for problem
fixed_factors (dict) – dictionary of user-specified problem factors
model_fixed_factors (dict) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dictionary) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a object) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dictionary

class simopt.models.mm1queue.MM1Queue(fixed_factors=None)¶

Bases: Model

A model that simulates an M/M/1 queue with an Exponential(lambda) interarrival time distribution and an Exponential(x) service time distribution. Returns

the average sojourn time

the average waiting time

the fraction of customers who wait

for customers after a warmup period.

name¶

name of model

Type: string

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters: fixed_factors (nested dict) – fixed factors of the simulation model

See also

check_lambda()¶

check_mu()¶

check_people()¶

check_simulatable_factors()¶

Determine if a simulation replication can be run with the given factors.

Notes

Each subclass of base.Model has its own custom check_simulatable_factors method.

Returns: is_simulatable – True if model specified by factors is simulatable, otherwise False.
Return type: bool

check_warmup()¶

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters

rng_list (list of mrg32k3a.mrg32k3a.MRG32k3a objects) – rngs for model to use when simulating a replication

Returns

responses (dict) – performance measures of interest “avg_sojourn_time” = average sojourn time “avg_waiting_time” = average waiting time “frac_cust_wait” = fraction of customers who wait
gradients (dict of dicts) – gradient estimates for each response

simopt.models.network module¶

Summary¶

Simulate messages being processed in a queueing network. A detailed description of the model/problem can be found here.

class simopt.models.network.Network(fixed_factors=None)¶

Bases: Model

Simulate messages being processed in a queueing network.

name¶

name of model

Type: str

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters: fixed_factors (dict) – fixed_factors of the simulation model

See also

check_arrival_rate()¶

check_cost_process()¶

check_cost_time()¶

check_lower_limits_transit_time()¶

check_mode_transit_time()¶

check_n_messages()¶

check_n_networks()¶

check_process_prob()¶

check_simulatable_factors()¶

Determine if a simulation replication can be run with the given factors.

Notes

Each subclass of base.Model has its own custom check_simulatable_factors method.

Returns: is_simulatable – True if model specified by factors is simulatable, otherwise False.
Return type: bool

check_upper_limits_transit_time()¶

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters

rng_list (list of mrg32k3a.mrg32k3a.MRG32k3a objects) – rngs for model to use when simulating a replication

Returns

responses (dict) – performance measure of interest “total_cost”: total cost spent to route all messages
gradients (dict of dicts) – gradient estimates for each response

class simopt.models.network.NetworkMinTotalCost(name='NETWORK-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Base class to implement simulation-optimization problems.

name¶

name of problem

Type: string

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: string

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: string

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: Model object

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: list of mrg32k3a.mrg32k3a.MRG32k3a objects

factors¶

changeable factors of the problem

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name for problem
fixed_factors (dict) – dictionary of user-specified problem factors
model_fixed_factors (dict) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dictionary) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a object) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dictionary

simopt.models.paramesti module¶

Summary¶

Simulate MLE estimation for the parameters of a two-dimensional gamma distribution. A detailed description of the model/problem can be found here.

class simopt.models.paramesti.ParamEstiMaxLogLik(name='PARAMESTI-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Base class to implement simulation-optimization problems.

name¶

name of problem

Type: string

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: string

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: string

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: model object

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: list of mrg32k3a.mrg32k3a.MRG32k3a objects

factors¶

changeable factors of the problem

initial_solutionlist: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take
prev_costlist: cost of prevention
upper_thresfloat > 0: upper limit of amount of contamination

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name for problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dictionary) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a object) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dictionary

class simopt.models.paramesti.ParameterEstimation(fixed_factors=None)¶

Bases: Model

A model that simulates MLE estimation for the parameters of a two-dimensional gamma distribution.

name¶

name of model

Type: string

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI and data validation)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters: fixed_factors (nested dict) – fixed factors of the simulation model

See also

base.model

check_simulatable_factors()¶

Determine if a simulation replication can be run with the given factors.

Notes

Each subclass of base.Model has its own custom check_simulatable_factors method.

Returns: is_simulatable – True if model specified by factors is simulatable, otherwise False.
Return type: bool

check_x()¶

check_xstar()¶

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters

rng_list (list of mrg32k3a.mrg32k3a.MRG32k3a objects) – rngs for model to use when simulating a replication

Returns

responses (dict) – performance measures of interest “loglik” = the corresponding loglikelihood
gradients (dict of dicts) – gradient estimates for each response

simopt.models.rmitd module¶

Summary¶

Simulate a multi-stage revenue management system with inter-temporal dependence. A detailed description of the model/problem can be found here.

class simopt.models.rmitd.RMITD(fixed_factors=None)¶

Bases: Model

A model that simulates a multi-stage revenue management system with inter-temporal dependence. Returns the total revenue.

name¶

name of model

Type: string

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI and data validation)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters: fixed_factors (nested dict) – fixed factors of the simulation model

See also

check_cost()¶

check_demand_means()¶

check_gamma_scale()¶

check_gamma_shape()¶

check_initial_inventory()¶

check_prices()¶

check_reservation_qtys()¶

check_simulatable_factors()¶

Determine if a simulation replication can be run with the given factors.

Notes

Each subclass of base.Model has its own custom check_simulatable_factors method.

Returns: is_simulatable – True if model specified by factors is simulatable, otherwise False.
Return type: bool

check_time_horizon()¶

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters

rng_list (list of mrg32k3a.mrg32k3a.MRG32k3a objects) – rngs for model to use when simulating a replication

Returns

responses (dict) – performance measures of interest “revenue” = total revenue
gradients (dict of dicts) – gradient estimates for each response

class simopt.models.rmitd.RMITDMaxRevenue(name='RMITD-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Base class to implement simulation-optimization problems.

name¶

name of problem

Type: string

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: string

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: string

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: Model object

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: list of mrg32k3a.mrg32k3a.MRG32k3a objects

factors¶

changeable factors of the problem

initial_solutiontuple: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name for problem
fixed_factors (dict) – dictionary of user-specified problem factors
model_fixed_factors (dict) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dictionary) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a object) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dictionary

simopt.models.san module¶

Summary¶

Simulate duration of a stochastic activity network (SAN). A detailed description of the model/problem can be found here.

class simopt.models.san.SAN(fixed_factors=None)¶

Bases: Model

A model that simulates a stochastic activity network problem with tasks that have exponentially distributed durations, and the selected means come with a cost.

name¶

name of model

Type: string

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI and data validation)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters: fixed_factors (nested dict) – fixed factors of the simulation model

See also

check_arc_means()¶

check_arcs()¶

check_num_nodes()¶

dfs(graph, start, visited=None)¶

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters

rng_list (list of mrg32k3a.mrg32k3a.MRG32k3a) – rngs for model to use when simulating a replication

Returns

responses (dict) – performance measures of interest “longest_path_length” = length/duration of longest path
gradients (dict of dicts) – gradient estimates for each response

class simopt.models.san.SANLongestPath(name='SAN-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Base class to implement simulation-optimization problems.

name¶

name of problem

Type: string

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: string

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: string

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: Model object

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: list of mrg32k3a.mrg32k3a.MRG32k3a objects

factors¶

changeable factors of the problem

initial_solutionlist: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name for problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_arc_costs()¶

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dictionary) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a object) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dictionary) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dictionary

simopt.models.sscont module¶

Summary¶

Simulate multiple periods worth of sales for a (s,S) inventory problem with continuous inventory. A detailed description of the model/problem can be found here.

class simopt.models.sscont.SSCont(fixed_factors=None)¶

Bases: 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.

name¶

name of model

Type: str

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters

fixed_factors (dict) –

fixed_factors of the simulation model

demand_mean: Mean of exponentially distributed demand in each period (flt)
lead_mean: Mean of Poisson distributed order lead time (flt)
backorder_cost: Cost per unit of demand not met with in-stock inventory (flt)
holding_cost: Holding cost per unit per period (flt)
fixed_cost: Order fixed cost (flt)
variable_cost: Order variable cost per unit (flt)
s: Inventory position threshold for placing order (flt)
S: Max inventory position (flt)
n_days: Number of periods to simulate (int)
warmup: Number of periods as warmup before collecting statistics (int)

See also

check_S()¶

check_backorder_cost()¶

check_demand_mean()¶

check_fixed_cost()¶

check_holding_cost()¶

check_lead_mean()¶

check_n_days()¶

check_s()¶

check_simulatable_factors()¶

Determine if a simulation replication can be run with the given factors.

Notes

Each subclass of base.Model has its own custom check_simulatable_factors method.

Returns: is_simulatable – True if model specified by factors is simulatable, otherwise False.
Return type: bool

check_variable_cost()¶

check_warmup()¶

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters

rng_list ([list] [mrg32k3a.mrg32k3a.MRG32k3a]) – rngs for model to use when simulating a replication

Returns

responses – performance measures of interest

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 an order was made
stockout_rate: fraction of periods a stockout occured
avg_stockout: mean amount of product backordered given a stockout occured
avg_order: mean amount of product ordered given an order occured

Return type

class simopt.models.sscont.SSContMinCost(name='SSCONT-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

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

name¶

name of problem

Type: str

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: str

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: str

lower_bounds¶

lower bound for each decision variable

Type: tuple

upper_bounds¶

upper bound for each decision variable

Type: tuple

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: base.Model

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: [list] [mrg32k3a.mrg32k3a.MRG32k3a]

factors¶

changeable factors of the problem

initial_solutiontuple: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name of problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also

check_deterministic_constraints(x)¶

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

Parameters: x (tuple) – vector of decision variables
Returns: satisfies – indicates if solution x satisfies the deterministic constraints.
Return type: bool

deterministic_objectives_and_gradients(x)¶

Compute deterministic components of objectives for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_objectives (tuple) – vector of deterministic components of objectives
det_objectives_gradients (tuple) – vector of gradients of deterministic components of objectives

deterministic_stochastic_constraints_and_gradients(x)¶

Compute deterministic components of stochastic constraints for a solution x.

Parameters

x (tuple) – vector of decision variables

Returns

det_stoch_constraints (tuple) – vector of deterministic components of stochastic constraints
det_stoch_constraints_gradients (tuple) – vector of gradients of deterministic components of stochastic constraints

factor_dict_to_vector(factor_dict)¶

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

Parameters: factor_dict (dict) – dictionary with factor keys and associated values
Returns: vector – vector of values associated with decision variables
Return type: tuple

get_random_solution(rand_sol_rng)¶

Generate a random solution for starting or restarting solvers.

Parameters: rand_sol_rng (mrg32k3a.mrg32k3a.MRG32k3a) – random-number generator used to sample a new random solution
Returns: x – vector of decision variables
Return type: tuple

response_dict_to_objectives(response_dict)¶

Convert a dictionary with response keys to a vector of objectives.

Parameters: response_dict (dict) – dictionary with response keys and associated values
Returns: objectives – vector of objectives
Return type: tuple

response_dict_to_stoch_constraints(response_dict)¶

Convert a dictionary with response keys to a vector of left-hand sides of stochastic constraints: E[Y] <= 0

Parameters: response_dict (dict) – dictionary with response keys and associated values
Returns: stoch_constraints – vector of LHSs of stochastic constraint
Return type: tuple

vector_to_factor_dict(vector)¶

Convert a vector of variables to a dictionary with factor keys

Parameters: vector (tuple) – vector of values associated with decision variables
Returns: factor_dict – dictionary with factor keys and associated values
Return type: dict

simopt.models.tableallocation module¶

Summary¶

Simulate multiple periods of arrival and seating at a restaurant. A detailed description of the model/problem can be found here.

class simopt.models.tableallocation.TableAllocation(fixed_factors=None)¶

Bases: Model

A model that simulates a table capacity allocation problem at a restaurant with a homogenous Poisson arrvial process and exponential service times. Returns expected maximum revenue.

name¶

name of model

Type: str

n_rngs¶

number of random-number generators used to run a simulation replication

Type: int

n_responses¶

number of responses (performance measures)

Type: int

factors¶

changeable factors of the simulation model

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

check_factor_list¶

switch case for checking factor simulatability

Type: dict

Parameters

fixed_factors (dict) –

fixed_factors of the simulation model

n_hours: Number of hours to simulate (int)
capacity: Maximum total capacity (int)
table_cap: Capacity of each type of table (int)
lambda: Average number of arrivals per hour (flt)
service_time_means: Mean service time in minutes (flt)
table_revenue: Per table revenue earned (flt)
num_tables: Number of tables of each capacity (int)

See also

check_capacity()¶

check_lambda()¶

check_n_hours()¶

check_num_tables()¶

check_service_time_means()¶

check_simulatable_factors()¶

Determine if a simulation replication can be run with the given factors.

Notes

Each subclass of base.Model has its own custom check_simulatable_factors method.

Returns: is_simulatable – True if model specified by factors is simulatable, otherwise False.
Return type: bool

check_table_cap()¶

check_table_revenue()¶

replicate(rng_list)¶

Simulate a single replication for the current model factors.

Parameters

rng_list ([list] [mrg32k3a.mrg32k3a.MRG32k3a]) – rngs for model to use when simulating a replication

Returns

responses – performance measures of interest

total_revenue: Total revenue earned over the simulation period.
service_rate: Fraction of customer arrivals that are seated.

Return type

class simopt.models.tableallocation.TableAllocationMaxRev(name='TABLEALLOCATION-1', fixed_factors=None, model_fixed_factors=None)¶

Bases: Problem

Class to make table allocation simulation-optimization problems.

name¶

name of problem

Type: str

dim¶

number of decision variables

Type: int

n_objectives¶

number of objectives

Type: int

n_stochastic_constraints¶

number of stochastic constraints

Type: int

minmax¶

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

Type: tuple of int (+/- 1)

constraint_type¶

description of constraints types:: “unconstrained”, “box”, “deterministic”, “stochastic”

Type: str

variable_type¶

description of variable types:: “discrete”, “continuous”, “mixed”

Type: str

gradient_available¶

indicates if gradient of objective function is available

Type: bool

optimal_value¶

optimal objective function value

Type: tuple

optimal_solution¶

optimal solution

Type: tuple

model¶

associated simulation model that generates replications

Type: base.Model

model_default_factors¶

default values for overriding model-level default factors

Type: dict

model_fixed_factors¶

combination of overriden model-level factors and defaults

Type: dict

model_decision_factors¶

set of keys for factors that are decision variables

Type: set of str

rng_list¶

list of RNGs used to generate a random initial solution or a random problem instance

Type: [list] [mrg32k3a.mrg32k3a.MRG32k3a]

factors¶

changeable factors of the problem

initial_solutiontuple: default initial solution from which solvers start
budgetint > 0: max number of replications (fn evals) for a solver to take

Type: dict

specifications¶

details of each factor (for GUI, data validation, and defaults)

Type: dict

Parameters

name (str) – user-specified name of problem
fixed_factors (dict) – dictionary of user-specified problem factors
factors (model_fixed) – subset of user-specified non-decision factors to pass through to the model

See also