nub.ts

import { ParamDefinition, Session } from ".";
import { ComputeNode } from "./compute-node";
import { Dichotomie } from "./dichotomie";
import { INamedIterableValues, IterableValues } from "./param/param-value-iterator";
import { ParamValueMode } from "./param/param-value-mode";
import { Props } from "./props";
import { Result } from "./util/result";
import { LinkedValue } 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 {

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

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

    private _props: Props = new Props();

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

    /** Returns Props object (observable set of key-values) associated to this Nub */
    public get properties(): Props {
        return this._props;
    }

    public set properties(props: Props) {
        this._props = props.clone();
    }

    /** Rapid accessor for calculator type */
    public get calcType() {
        return this._props.getPropValue("calcType");
    }

    /**
     * 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
     */
    public Calc(sVarCalc: string, rInit?: number): 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);
        if (!resSolve.ok) {
            this._result = resSolve;
            this._result.name = sVarCalc;
            return this._result;
        }
        const sAnalyticalPrm: string = this.getFirstAnalyticalParameter().symbol;