nub.ts

import { ParamDefinition, ParamsEquation } from ".";
import { ComputeNode } from "./compute-node";
import { Dichotomie } from "./dichotomie";
import { INamedIterableValues, INumberIterator, IterableValues } from "./param/param-value-iterator";
import { ParamValueMode } from "./param/param-value-mode";
import { ParamValues } from "./param/param-values";
import { Props } from "./props";
import { Result } from "./util/result";
import { IReferencedNub } from "./value_ref/object_ref";

/**
 * Classe abstraite de Noeud de calcul dans une session :
 * classe de base pour tous les calculs
 */
export abstract class Nub extends ComputeNode implements IReferencedNub {

    /** paramétrage de la dichotomie */
    public dichoStartIntervalMaxSteps: number = 100;

    /** résultat de Calc()/CalcSerie() */
    protected _result: Result;

    private _props: Props;

    public get result(): Result {
        return this._result;
    }

    public get properties() {
        return this._props;
    }

    // originally in SessionNub
    public set properties(props: Props | {}) {
        const params = props instanceof Props ? props : new Props(props);
        this._props = params.clone();
    }

    /**
     * Formule utilisée pour le calcul analytique (solution directe ou méthode de résolution spécifique)
     */
    public abstract Equation(sVarCalc: string): Result;

    /**
     * Calcul d'une équation quelle que soit l'inconnue à calculer
     * @param sVarCalc nom de la variable à calculer
     * @param rInit valeur initiale de la variable à calculer dans le cas de la dichotomie
     * @param rPrec précision de calcul
     */
    public Calc(sVarCalc: string, rInit?: number, rPrec: number = 0.001): Result {
        const computedVar = this.getParameter(sVarCalc);

        if (rInit === undefined) {
            rInit = computedVar.v;
        }
        if (computedVar.isAnalytical()) {
            this._result = this.Equation(sVarCalc);
            this._result.name = sVarCalc;
            return this._result;
        }

        const resSolve: Result = this.Solve(sVarCalc, rInit, rPrec);
        if (!resSolve.ok) {
            this._result = resSolve;
            this._result.name = sVarCalc;
            return this._result;
        }
        const sAnalyticalPrm: string = this.getFirstAnalyticalParameter().symbol;
        computedVar.setValue(resSolve.vCalc);
        const res: Result = this.Equation(sAnalyticalPrm);