Package-level declarations
Types
Checks for equality between solutions based whether the confidence interval on the difference contains the indifference zone parameter.
Represents an estimated response based on an independent sample. For the case of sample size 1 (count equals 1), the variance will be undefined (Double.NaN).
An interface to define basic statistics for something that is estimated.
An evaluation request is used to request simulation oracle execution on a model.
An evaluator should communicate with the simulation oracle to determine solutions for requests for evaluation from solvers.
A clock-independent, feasibility-first ordering used to select the recommended solution — distinct from the penalized-objective ordering (Solution.compareTo) used to guide the search within an iteration.
This solution comparator returns 0 if the inputs are the same for the two solutions. If the solutions do not have the same inputs, then the penalized objective function is used to determine the ordering. Thus, two solutions are considered the same if they have the same input values, regardless of the value of the objective functions.
Checks for equality between solutions based whether the confidence interval on the difference contains the indifference zone parameter and whether the input variable values are the same.
One observation of a single response at a design point — the single-response form of ResponseFunctionIfc, in the style of ksl.utilities.mcintegration.MCReplicationIfc extended with design-point inputs. The same component contract applies: acquire all randomness at construction from the provider the instance was built against, and be pure apart from consuming those streams.
A convenience adaptor: a single-response SimulationOracleIfc over a static Monte Carlo replication function. All behavior (macro/micro replication semantics, provider-wide stream positioning, CRN, contract enforcement, failure mapping, thread confinement) is delegated to a ResponseFunctionOracle over the single response.
The data associated with a request for a simulation evaluation. A critical aspect of this implementation is how the equality of instances is determined.
Compares solutions based on granular objective function values.
Options that select and configure parallel evaluation when building an evaluator via Evaluator.createProblemEvaluator (and the Solver.create* factories that delegate to it).
A SimulationOracleIfc that executes the points of an EvaluationRequest concurrently, each on its own freshly built Model, honoring the request's common-random-numbers (CRN) vs. independent stream choice through per-point run parameters.
A comparator for solutions based on the penalized objective function values.
Checks for equality between solutions based whether the confidence interval on the difference contains the indifference zone parameter.
Equality of the solutions is based on the penalized objective function values being within a specific precision.
Compares solutions based on granular penalized objective function values.
Builds a fresh ResponseFunctionIfc bound to the supplied stream provider — the response-function counterpart of ksl.simulation.ModelBuilderIfc. Concurrent execution creates one instance per member, each against that member's own identically seeded provider, so members are isolated while remaining reproducible.
One observation of every response at a design point. Implementations are small components in the standard KSL style: they acquire ALL of their randomness at construction time from the stream provider they are built against (typically as random variables with explicit stream numbers, exactly like a simulation model's random variables), and each call to the replication function makes one noisy observation by drawing from those pre-acquired streams.
A SimulationOracleIfc over a response function instead of a discrete-event simulation model. Everything above the oracle seam — caching, common random numbers, solution merging, the solvers, and the concurrent execution substrate — is oracle-agnostic, so a cheap synthetic problem (noisy test function, static Monte Carlo model) evaluated through this class exercises exactly the same machinery as an expensive simulation.
A response map holds replication data from evaluations of the simulation oracle. The key to the map is the response name, which should match a named response within the simulation model and within the problem definition. The associated list of doubles is the within replication average for each replication.
A snapshot of solver-level search state captured at evaluation time and carried on a Solution, for self-scaling penalty functions (e.g., near-feasibility-threshold schemes) that need global context rather than only per-solution memory. Null until such penalties are used; populating it is a future (solver-level) concern.
An interface to define something that can simulate evaluation requests.
This simulation provider will execute evaluation requests on the same model and collect the desired responses. This provider runs the model's replications locally and sequentially in the same execution thread as the requests.
An interface that promises to run simulations on instances of input/output pairs. The keys of the map are evaluation requests for a specific number of replications for specific input variable values. The associated ResponseMap represents the desired responses from the simulation. It should contain the replication averages for each desired response.
This simulation service will execute evaluation requests on models and collect the desired responses.
A solution represents the evaluated inputs for on a problem definition. Solution also implements the EstimatedResponseIfc interface by delegating to the supplied estimated objective function. The FeasibilityIfc interface is implemented by delegating to the supplied input map.
A solution checker holds solutions up to a capacity (threshold). The solution checker will hold a maximum number of solutions to check (capacity/threshold). If the contained solutions all test as equal, then the checker returns true.
A functional interface for checking if two solutions are equal.
Class to support a group of solutions (all containing inputs, responses, objective fns, penalties) The solutions are naturally ordered by comparison of Solution instances based on their penalized objective functions (without regard to sampling error).
Computes the sub-stream advance applied before each point of an EvaluationRequest is run, so that consecutive requests draw fresh, non-overlapping random numbers — exactly the way a reused model's streams advance continuously in SimulationProvider.