ComparisonWithStandardProcedure

class ComparisonWithStandardProcedure(var alpha: Double = DEFAULT_ALPHA, var delta: Double, var n0: Int = DEFAULT_N0, var c: Int = 1, var maxReplications: Int = DEFAULT_MAX_REPLICATIONS)(source)

Kim's (2005) fully-sequential comparison with a standard procedure, used by COMPASS as the local-optimality test: the current center x* is the standard, its neighbors are the alternatives, and the procedure decides — with a controlled error probability — whether any neighbor is better than x* by more than the indifference amount delta.

Each system starts with n0 replications. For each alternative i the per-replication difference d_j = alt_i_j - standard_j (minimization, so a negative mean means the alternative is better) is accumulated into Z_i(r) = Σ d_j. A triangular continuation region with half-width a_i(r) = max(0, h² S²_i / (2δ) − (δ/2) r) brackets the walk, where S²_i is the first-stage sample variance of the differences and h² = 2 η (n0 − 1). At each stage:

  • Z_i(r) < −a_i(r) ⇒ alternative i is significantly better than the standard ⇒ the standard loses and i is the winner;

  • Z_i(r) > +a_i(r) ⇒ alternative i is significantly worse ⇒ eliminate i;

  • otherwise keep sampling i.

When every alternative has been eliminated the standard is declared best. Bonferroni splits the error across the k alternatives: β = α / k and η = ½ ((2β)^(−2/(n0−1)) − 1) (the closed form for the single-constant case, c = 1).

This procedure requires a positive delta; with delta == 0 the boundary degenerates and the walk never terminates, which is why COMPASS uses it only when δ_L > 0 (see the ISC degraded-mode documentation).

Parameters

alpha

the overall error probability; must be in (0,1)

delta

the indifference-zone parameter δ_L; must be positive

n0

the first-stage sample size per system; must be at least 2

c

the comparison-constant flag from Kim (2005); only c = 1 is supported

maxReplications

a hard cap on replications per system, guaranteeing termination even if the boundary has not forced a decision; must be at least n0

Constructors

Link copied to clipboard
constructor(alpha: Double = DEFAULT_ALPHA, delta: Double, n0: Int = DEFAULT_N0, c: Int = 1, maxReplications: Int = DEFAULT_MAX_REPLICATIONS)

Types

Link copied to clipboard
object Companion

Properties

Link copied to clipboard
Link copied to clipboard
var c: Int
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
var n0: Int

Functions

Link copied to clipboard
fun eta(beta: Double): Double

The Kim (2005) constant η for the given per-alternative error beta (the closed form for c = 1): η = ½ ((2β)^(−2/(n0−1)) − 1).

Link copied to clipboard
fun run(standard: Solution, alternatives: List<Solution>, sampleOneMore: (InputMap) -> Solution, merge: (Solution, Solution) -> Solution): StandardComparisonResult

Runs the fully-sequential comparison. standard and each of the alternatives must already carry at least n0 replications. sampleOneMore is invoked to obtain one additional replication for a given point (the returned Solution is for that point with one more observation, not the merged total) — the procedure merges it internally via the supplied merge function so that callers control how accumulation happens.