KSLCore/ksl.simopt.problem

Package-level declarations

Types

class DynamicPolynomialPenalty(val basePenalty: Double = 100.0, val violationExponent: Double = 2.0, val iterationExponent: Double = 1.0) : PenaltyFunctionIfc

A dynamic polynomial penalty function that scales based on both the magnitude of the constraint violation and the current iteration of the solver.

FeasibilityCheckerIfc

fun interface FeasibilityCheckerIfc

FeasibilityIfc

interface FeasibilityIfc

FixedStartingPoint

class FixedStartingPoint(val point: MutableMap<String, Double>) : StartingPointIfc

FunctionalConstraint

class FunctionalConstraint(validNames: List<String>, val lhsFunc: ConstraintFunctionIfc, val rhsValue: Double = 0.0, val inequalityType: InequalityType = InequalityType.LESS_THAN) : ConstraintIfc

Represents a functional constraint in an optimization problem.

InequalityType

enum InequalityType : Enum<InequalityType>

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.

InputDefinition

class InputDefinition @JvmOverloads constructor(val name: String, val lowerBound: Double, val upperBound: Double, granularity: Double = 0.0)

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.

InputMap

class InputMap : Map<String, Double> , FeasibilityIfc

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.

LatinHyperCubePointGenerator

class LatinHyperCubePointGenerator @JvmOverloads constructor(val pointsPerDimension: Int, val problemDefinition: ProblemDefinition, streamNum: Int = 0, streamProvider: RNStreamProviderIfc = KSLRandom.DefaultRNStreamProvider) : StartingPointIfc

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.

LinearConstraint

data class LinearConstraint(val equation: Map<String, Double>, var rhsValue: Double = 0.0, val inequalityType: InequalityType = InequalityType.LESS_THAN) : ConstraintIfc

Represents a linear-constraint for a ProblemDefinition.

OptimizationType

enum OptimizationType : Enum<OptimizationType>

PenaltyFunctionIfc

fun interface PenaltyFunctionIfc

A penalty function that is applied to the violation of a constraint of an optimization problem. The penalty function is a function of the violation and the current iteration count. The penalty for the constraint is added to the objective function of the problem.

PenaltyFunctionWithMemory

class PenaltyFunctionWithMemory(val basePenalty: Double = 100.0, val iterationExponent: Double = 1.0, val violationExponent: Double = 2.0) : PenaltyFunctionIfc

A penalty function adapted for Simulation Optimization based on the "Memory" principles of Park and Kim (2015). Park, C., & Kim, S. H. (2015). Penalty Function with Memory for Discrete Optimization via Simulation with Stochastic Constraints. Operations Research, 63(5), 1195-1212. This function scales the dynamic multiplier using the sample count (memory) to prevent stochastic noise from infinitely penalizing boundary solutions.

ProblemDefinition

class ProblemDefinition @JvmOverloads constructor(problemName: String? = null, val modelIdentifier: String, val objFnResponseName: String, inputNames: List<String>, responseNames: List<String> = emptyList(), val optimizationType: OptimizationType = OptimizationType.MINIMIZE, indifferenceZoneParameter: Double = 0.0, objFnGranularity: Double = 0.0) : IdentityIfc

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.

ResponseConstraint

class ResponseConstraint(val responseName: String, val rhsValue: Double, val inequalityType: InequalityType = InequalityType.LESS_THAN, val target: Double = 0.0, val tolerance: Double = 0.0, val penaltyFunction: PenaltyFunctionIfc? = null)

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.

StartingPointIfc

fun interface StartingPointIfc