KSLCore/ksl.simopt.problem

Package-level declarations

Types

ConstraintFunctionIfc

fun interface ConstraintFunctionIfc

ConstraintIfc

interface ConstraintIfc

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(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.

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.

ProblemDefinition

class ProblemDefinition @JvmOverloads constructor(problemName: String? = null, val modelIdentifier: String, val objFnResponseName: String, inputNames: List<String>, responseNames: List<String> = emptyList(), 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)

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