KSLCore/ksl.simopt.problem/InputMap

InputMap

class InputMap : Map<String, Double> , FeasibilityIfc(source)

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.

Parameters

map

the map containing the (name, value) pairs associated with inputs for the evaluation process. These names and values must be valid with respect to the problem. The name must be a valid name for the problem, and the value must be within the input variable's defined range of possible values.

Properties

inputValues

val inputValues: DoubleArray

names

val names: List<String>

problemDefinition

val problemDefinition: ProblemDefinition

Functions

asMutableMap

fun asMutableMap(): MutableMap<String, Double>

A copy of the input map as a mutable map

changeInputVariable

fun changeInputVariable(inputName: String, value: Double): InputMap

Creates a new instance of an InputMap that is a copy of the current instance but with the value associated with the specified inputName changed to the provided value

equals

open operator override fun equals(other: Any?): Boolean

hashCode

open override fun hashCode(): Int

isFunctionalConstraintFeasible

open override fun isFunctionalConstraintFeasible(): Boolean

Interprets the supplied map as inputs for the problem definition and returns true if the values are within functional constraints. False will be returned if at least one functional constraint is infeasible.

isInputFeasible

open override fun isInputFeasible(): Boolean

The supplied input is considered input-feasible if it is feasible with respect to the defined input parameter ranges, the linear constraints, and the functional constraints.

isInputRangeFeasible

open override fun isInputRangeFeasible(): Boolean

Interprets the supplied map as inputs for the problem definition and returns true if the values are within the ranges defined for the variables. False will be returned if at least one input variable is not within its defined range.

isLinearConstraintFeasible

open override fun isLinearConstraintFeasible(): Boolean

Interprets the supplied map as inputs for the problem definition and returns true if the values are within linear constraints. False will be returned if at least one linear constraint is infeasible.

perturbedBy

fun perturbedBy(stepSize: Double, rnStream: RNStreamIfc = KSLRandom.defaultRNStream()): InputMap

Perturbs the current input values by the supplied step size. Each input is randomly increased or decreased by the step size. The likelihood of increasing or decreasing the value is equally likely.

randomizeInputVariable

fun randomizeInputVariable(rnStream: RNStreamIfc = KSLRandom.defaultRNStream(), name: String = problemDefinition.randomInputName(rnStream)): InputMap

Randomly generates a new value for the named input variable and returns a new input map. Randomization is uniformly distributed over the range of the input variable with no memory of its current value.

toString

open override fun toString(): String

validateInputVariable

fun validateInputVariable(inputName: String, value: Double): Boolean

Checks if the supplied value is a valid input value for the supplied input name.