dichotomie.ts

import { BoolIdentity, Debug } from "./base";
import { Nub } from "./nub";
import { ParamDefinition } from "./param/param-definition";
import { ParamDomain, ParamDomainValue } from "./param/param-domain";
import { Interval } from "./util/interval";
import { Message, MessageCode } from "./util/message";
import { Result } from "./util/result";

class SearchInterval extends Interval {
    private _step: number;

    private _dicho: Dichotomie;

    private _targets: Interval;

    constructor(d: Dichotomie, min: number, max: number, s: number) {
        super(min, max);
        if (s === 0) {
            const e = new Message(MessageCode.ERROR_DICHO_NULL_STEP);
            throw e;
        }
        this._step = s;
        this._dicho = d;
    }

    public reverse() {
        this._step = -this._step;
    }

    public growStep(k: number) {
        if (k === 0) {
            const e = new Message(MessageCode.ERROR_DICHO_INVALID_STEP_GROWTH);
            throw e;
        }
        this._step *= k;
    }

    get step() {
        return this._step;
    }

    get targets() {
        if (this._targets === undefined) {
            // @TODO just set _targets to undefined / null ?
            this._targets = new Interval(undefined, undefined);
        }
        return this._targets;
    }

    /**
     * get target value for lower bound
     */
    get targetLower() {
        this.updateTargets();
        // @TODO val1 is not guaranteed to be the lower bound; use .min ?
        return this.targets.val1;
    }

    /**
     * get target value for upper bound
     */
    get targetUpper() {
        this.updateTargets();
        // @TODO val2 is not guaranteed to be the upper bound; use .max ?
        return this.targets.val2;
    }

    public next() {
        if (this._step > 0) {
            this.val1 = this.val2;