Package-level declarations
Types
The foundational appreciation/depreciation penalty sequence of Park and Kim (2015, Eq. 4): the penalty is multiplied by the appreciation factor appreciationFactor (a, greater than 1) when the solution looks infeasible (standardized measure S greater than 0) and by the depreciation factor depreciationFactor (d, between 0 and 1) when it looks feasible (S at most 0). This makes the sequence diverge for infeasible solutions and converge to zero for interior feasible solutions, satisfying Park and Kim's Condition 1 for those cases. For boundary (active) solutions it converges only in distribution (their Theorem 3), with positive probability of not vanishing — the precise gap that the convergence-optimized PS1/PS2 close. This class is that foundational sequence, not PS1 or PS2.
A dynamic polynomial penalty that scales with both the magnitude of the constraint violation and the current iteration of the solver:
A structured description of whether a problem's input lattice can supply a requested number of distinct feasible input points — for example a solver population or a space-filling design. Produced by ProblemDefinition.feasiblePointCapacity, it lets a caller decide programmatically (e.g. cap a population, flag a benchmark cell, drive a UI) rather than parse a log message.
Represents a functional constraint in an optimization problem.
enum to codify < and > in constraints for user convenience in problem definition. (Internally all input and response constraints are implemented as <) We could instead adopt one version (typically < in the literature) and force the user to modify their coefficients.
Represents the definition of an input variable for a ProblemDefinition. Input variables are the variables used in the problem to model the decision parameter of the simulation model. The input variable name should correspond to some named parameter (e.g., control) in the model.
Two InputMaps are considered equal if their (name, value) pairs are the same. This class prevents the keys and values from changing. This prevents an input map associated with a solution from being changed. InputMap instances are the keys for solution caches. Thus, we cannot change the key of the solution cache. The user cannot construct an input map that is infeasible with respect to the input variable ranges.
Creates a Latin hyper-cube sampler with each dimension divided into the specified number of points. The hyper-cube is formed from the specified intervals of the problem. The sampling will ensure input feasible starting points.
Represents a linear-constraint for a ProblemDefinition.
Park and Kim (2015) Penalty-Function-with-Memory state for one (design point, constraint): the number of visits, the cumulative standardized measure of violation (the sum of the per-visit measures), and the current penalty-sequence value. The snapshot is immutable; a new one is produced at each visit and carried on the Solution, so it persists across visits via the solution cache.
The Park and Kim (2015) Penalty Function with Memory (PFM) for a stochastic (response) constraint.
The capability that a penalty function binds to (Option B): a constraint that can report its own violation magnitude for a given solution. Deterministic constraints (ConstraintIfc) read the solution's input values; response constraints (ResponseConstraint) read the estimated response.
A penalty function applied to a constraint's violation; the penalty is added to the problem's objective function.
Per-(design-point, constraint) memory carried by a solution to support memoryful penalty functions such as the Park and Kim (2015) Penalty Function with Memory. Each penalty type defines its own concrete subtype, so new penalty families carry whatever state they need. Snapshots are immutable and ride on the (immutable) solution, persisted across visits by the solution cache.
The penalty-sequence rule for a memoryful penalty (Park and Kim 2015). Given the penalty value carried from a solution's previous visit and the solution's accumulated standardized measure of violation, it produces the penalty value for the current visit. Any implementation should satisfy Park and Kim's Condition 1 (the sequence converges to 0 for a feasible constraint and diverges to infinity for an infeasible constraint) so the penalized objective converges.
This class describes an optimization problem for use within simulation optimization algorithms. The general optimization problem is presented as minimizing the expected value of some function H(x), where x is some input parameters to the simulation and H(.) is the simulation model response for the objective function. The input parameters are assumed to be real-valued specified by a name between a lower and upper bound and a granularity. The granularity specifies the acceptable precision of the input. The problem can have a set of linear constraints. The linear constraints are a deterministic function of the inputs. The problem can also have a set of functional constraints. A functional constraint is a deterministic function of the inputs that is bounded by constraints. This permits non-linear deterministic functional forms for the problem. In addition, a set of probabilistic constraints of the form EG(x)< c can be specified, where G(x) is some response from the simulation.
A response constraint represents a general constraint of the form ER(x)< b or ER(x)> b where R(x) is some response from the model that is a function of the model inputs.