ParkKimPenalty

class ParkKimPenalty(val sequence: PenaltySequence, val fallback: PenaltyFunction = DynamicPolynomialPenalty(), constraint: PenalizableConstraint? = null) : PenaltyFunction(source)

The Park and Kim (2015) Penalty Function with Memory (PFM) for a stochastic (response) constraint.

Unlike the memoryless DynamicPolynomialPenalty, PFM accumulates a per-solution memory across visits (ParkKimMemory): a standardized measure of violation S that magnifies infeasibility as observations accumulate (Park and Kim 2015, Section 3.1), and a penalty sequence that appreciates for solutions that look infeasible and depreciates for those that look feasible (the sequence). The ranking-time contribution is lambda * (S)+ (their Section 3.1). The memory is folded at evaluation time by the evaluator via foldVisit and carried on the Solution; penalty only reads it, so the penalized objective stays a pure function of the solution.

Scope: this uses Park and Kim's foundational appreciation/depreciation sequence (their Eq. 4; see AppreciateDepreciateSequence). Their convergence-optimized sequences PS1 (Figure 3) and PS2 (Section 3.3) are NOT implemented here — they require global search state (chiefly the adaptive cap M0 of their Eq. 5) and drop into sequence without engine changes. Citation note: the standardized measure, its visit-mean S, and the penalized objective are the inline definitions of Park and Kim's Section 3.1 (the same quantities are numbered Eq. 2-3 in the Han et al. 2021 improved-PFM paper, whose numbering earlier drafts of this code used).

Graceful degradation (no growing-replication schedule is required): with fewer than two accumulated visits the memory is a single noisy measure, so penalty uses fallback (a memoryless polynomial penalty). PFM engages once a design point has been re-sampled (two or more visits). If the evaluation regime never re-samples a design point, PFM therefore behaves exactly as fallback.

PFM is meant for response (stochastic) constraints, whose observations can be standardized. If it is bound to a deterministic constraint (which produces no observations), no memory ever accumulates and penalty simply uses fallback.

Parameters

sequence

the penalty-sequence rule (Park and Kim Eq. 4 appreciation/depreciation, or a future sequence such as PS2+)

fallback

the memoryless penalty used until memory accumulates, and whenever memory is absent

constraint

the bound constraint, or null for an unbound default template

Constructors

Link copied to clipboard
constructor(sequence: PenaltySequence, fallback: PenaltyFunction = DynamicPolynomialPenalty(), constraint: PenalizableConstraint? = null)

Properties

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
open override val usesMemory: Boolean

True when this penalty accumulates memory across visits, so the evaluator folds each visit's new observations into it. Memoryless penalties leave this false and carry no memory.

Functions

Link copied to clipboard

Returns a copy of this penalty bound to the supplied constraint. Used to resolve a default template into a per-constraint instance.

Link copied to clipboard
open override fun foldVisit(newObservations: EstimatedResponse, prior: PenaltyMemory?, iteration: Int): PenaltyMemory

Folds a visit's new observations for this penalty's constraint into the prior memory, returning the snapshot to carry on the resulting solution. Memoryless penalties keep the default (null).

Link copied to clipboard
open override fun penalty(solution: Solution): Double

The penalty contribution for this penalty's constraint at the supplied solution. Must be a pure function of the solution (and this penalty's own state) so that the penalized objective is a stable, Solver-free property of an immutable solution. Called only on bound instances.