AutoMovie API
    Preparing search index...

    Minimise from an iterate. What a solve is run with.

    interface IOptions {
        ceiling?: number;
        from?: number;
        penalties: readonly number[];
        radius?: number;
        rounds: number;
        schedule: ISchedule;
        stationary?: number;
        steer?: boolean;
    }
    Index
    ceiling?: number

    The greatest penalty the steering may reach: a growth that would pass it is not made, and the round goes on with the step at the penalty reached, as it does when STEERING.increases are spent. Unbounded when absent; read only with steer.

    from?: number

    The penalty to start at, a solve continued from another's result (IResult.penalty); the first when absent.

    penalties: readonly number[]

    The penalties, ascending, each tried while the constraints are not met at the one before.

    radius?: number

    The region's first half-width, a solve following another of the same kind (IResult.radius); ISchedule.trust when absent.

    rounds: number

    Convexifications per penalty at most.

    schedule: ISchedule

    The region's schedule.

    stationary?: number

    The least reduction of the violation the caller can tell, in the violation's units: its own feasibility tolerance. Where the steering's step of the violation alone lies inside its region (not at its edge), it is the linearised violation's own least; reducing the violation by no more than this while the iterate violates by more, it shows the iterate a first-order stationary point of the violation, an infeasible one that no later round leaves, and the solve stops there with reason infeasible. Absent, a solve runs its rounds; read only with steer.

    steer?: boolean

    Whether the penalty is steered (Byrd, Nocedal and Waltz 2008, "Steering exact penalty methods for nonlinear programming", Optim Methods Softw 23:197; Algorithm 5.1, p. 11 of the 2007 technical report): each round, where the step at the penalty leaves the linearised constraints violated (IStep.met), the step of the violation alone (the model without the objective, their (5.10)) sets the progress a step can make; the penalty grows by STEERING.increase until the step meets the linearised constraints where that one does, or else reduces their violation by at least STEERING.feasibility of what that one does (their (5.13), p. 10), and then until the model's decrease is at least STEERING.merit times the penalty times the step's reduction of the violation (their (5.14), p. 10). The penalty is then tied to the problem at every iterate, so a start the constraints' linearisation cannot satisfy is not pulled off them by the objective, and the steps keep their progress on feasibility. With it, penalties gives only the first penalty and from a continued one. False when absent.