ISCSolver
The three-phase Industrial Strength COMPASS (ISC) driver: a global Niching-GA exploration phase, a local COMPASS phase run once per niche seed, and a clean-up ranking-and-selection phase that screens the local optima, selects the best, and reports a confidence interval. It orchestrates the in-package NichingGeneticAlgorithmSolver, CompassSolver, and CleanUpProcedure as a phase state machine: each mainIteration advances one macro-step (run the global phase, run one local search, or finish with clean-up).
Requires an integer-ordered problem definition. ISC's COMPASS local phase searches an integer lattice (unit-step neighborhood), so every input must have granularity 1.0. The constructor throws an IllegalArgumentException when the problem is not integer-ordered.
Indifference zones and graceful degradation. A single user parameter deltaC drives the statistical guarantees, with deltaL (COMPASS local-optimality) defaulting to it:
deltaC > 0— full ISC. Clean-up runs the Rinott indifference-zone selection and reportsḡ(x_B) ± δ_Cwith the correct-selection guarantee; withdeltaL > 0each COMPASS run confirms local optimality with Kim's (2005) sequential test.deltaC = 0(the default, inherited from ProblemDefinition.indifferenceZoneParameter) — degraded. ISC still returns a feasible best, but the IZ-dependent guarantees are intentionally dropped: clean-up degrades to screening + an ordinary confidence interval (no±δ_Ccorrect-selection guarantee), and COMPASS stops on the most-promising-area singleton condition plus the iteration budget. A positiveδ_Cis required to obtain the guarantees.
Set globalPhase to null (or use the COMPASS-only factory) for the paper's unimodal shortcut: the global phase is skipped and a single COMPASS run starts from the configured starting point (or a random feasible point).
The best solution found is tracked automatically by the base class through currentSolution; the selected best and its confidenceInterval are finalized by the clean-up phase.
Reading the result (D2). For ISC, read the answer from currentSolution together with confidenceInterval — that pair is the clean-up-selected best and its interval. The generic Solver.bestSolution returns the minimum penalized point estimate across every solution the run produced (including unconfirmed niching-GA population members), which can differ from — and is less trustworthy than — the ranking-and-selection winner that confidenceInterval describes.
Parameters
the problem being solved
the evaluator responsible for assessing the quality of solutions
the random number stream number; 0 (the default) means the next available stream
the provider of random number streams shared with the sub-solvers
strategy for the number of replications per evaluation
the clean-up indifference zone δ_C; defaults to the problem's IZ parameter
the COMPASS local-optimality indifference zone δ_L; defaults to deltaC
when true, skip the global phase (COMPASS-only unimodal shortcut)
the Niching-GA global phase; when null and not skipped, a default is built
builds a CompassSolver for a given seed point; when null a default is used
the clean-up procedure; when null a default is built from deltaC
an optional replication budget that adds a BudgetRule to a default global phase
the maximum number of orchestration macro-steps
the per-run replication cap for a default COMPASS local phase (see CompassSolver.maxReplications); ignored when a localPhaseFactory is supplied, since the factory then owns its solvers. Defaults to CompassSolver.defaultMaxReplications.
the per-survivor Rinott second-stage cap for a default clean-up phase (see CleanUpProcedure.maxReplicationsPerSystem); ignored when cleanUp is supplied. Defaults to CleanUpProcedure.DEFAULT_MAX_REPLICATIONS_PER_SYSTEM.
an optional name for the solver
Constructors
Constructs an ISC solver using a fixed number of replications per evaluation.
Types
Properties
The clean-up procedure used to screen, select, and report.
The confidence interval reported by the clean-up phase for the selected best.
Structured, ordered snapshot of the solver's configuration — the same fields the toString implementations expose, in a form that downstream consumers can iterate (reporting, machine-readable summary artifacts, "compare two runs" tooling).
The local optima collected from the COMPASS runs (one per niche seed).
The current orchestration phase.
Whether the global (Niching-GA) phase is skipped.
Functions
A hook for subclasses to inject their specific internal state metrics into the snapshot without having to override the entire makeSolverStateSnapshot method.
Subclasses may implement this function to prepare the solver before running the first iteration. Generally, it is sufficient to just implement the startingPoint() function.
Subclasses should implement this function to determine if the solver should continue running iterations. This will likely include some implementation of stopping criteria. This function should implement stopping criteria based on the quality of the solution. The number of iterations, compared to the maximum number of iterations, is automatically checked after each step in the iterative process. Unless overridden, this function returns false by default, which indicates that the solution quality criteria have not been satisfied. This will cause the solver to iterate through all iterations of the solution process up to the maximum number of iterations. Alternatively, the user can specify an instance of the SolutionQualityEvaluatorIfc interface to determine if the solution quality has been reached.
This function should contain the logic that iteratively executes until the maximum number of iterations is reached or until the stopping criteria is met. The base implementation calls nextPoint() to determine the next point to evaluate, requests an evaluation of the point, and then updates the current solution if the resulting solution is better than the current solution. Generally, implementing startingPoint() and nextPoint() should be adequate. The property iterationCounter represents the current iteration within the mainIteration() function. That is, the value of iterationCounter is incremented prior to the execution of the mainIteration() function.
Subclasses should implement this function to clean up after running all iterations. That is, after the main iteration has stopped. This may include such concepts as selecting the best once all iterations have completed.