jalhyd/build/dichotomie.d.ts

JaLHyd, a Javascript Library for Hydraulics

import { Debug } from "./internal_modules";
import { Nub } from "./internal_modules";
import { Result } from "./internal_modules";
/**
 * calcul par dichotomie
 * principe : y=f(x1,x2,...), on connait une valeur de y,
 * on cherche par ex le x2 correspondant, les autres xi étant fixés.
 * la méthode Equation() calcule analytiquement y=f(xi)
 */
export declare class Dichotomie extends Debug {
    private nub;
    private sVarCalc;
    /**
     * définition de la variable de la fonction
     */
    private _paramX;
    /**
     * nombre d'étapes de recherche de l'intervalle de départ
     */
    private _startIntervalMaxSteps;
    /**
     * nom du paramètre calculé analytiquement par Equation()
     */
    private analyticalSymbol;
    /**
     * Targetted value calculated by the function
     */
    private _target;
    private _func;
    /**
     * si > 0, un calcul dichotomique est en cours
     */
    private static _inDicho;
    /**
     * Construction de la classe.
     * @param nub Noeud de calcul contenant la méthode de calcul Equation
     * @param sVarCalc Nom de la variable à calculer
     */
    constructor(nub: Nub, sVarCalc: string, dbg?: boolean, func?: () => number);
    private set vX(value);
    /**
     * étapes de recherche de l'intervalle de départ
     */
    get startIntervalMaxSteps(): number;
    set startIntervalMaxSteps(n: number);
    static get inDicho(): boolean;
    CalculX(x: number): number;
    /**
     * trouve la valeur x pour y=f(x) avec un y donné
     * @param rTarget valeur de y
     * @param rTol tolérance pour l'arrêt de la recherche
     * @param rInit valeur initiale approximative de x
     */
    Dichotomie(rTarget: number, rTol: number, rInit: number): Result;
    debug(s: string): void;
    /**
     * Calcul de l'équation analytique.
     * @note Wrapper vers this.nub.Equation pour simplifier le code.
     * On utilise la première variable du tableau des variables pouvant être calculée analytiquement
     * Il faudra s'assurer que cette première variable correspond à la méthode de calcul la plus rapide
     */
    private Calcul;
    /**
     * Détermine si une fonction est croissante ou décroissante.
     * @param x point auquel on calcul la dérivée
     * @param dom domaine de définition de la variable
     */
    private isIncreasingFunction;
    /**
     * recherche l'intervalle contenant la valeur cible
     * @param rTarget valeur cible
     * @param intSearch intervalle de départ
     * @param intMax intervalle maximum (domaine de définition de la variable)
     */
    private searchTarget;
    /**
     * Détermine l'intervalle de recherche initial
     * @param rTarget valeur cible de la fonction
     * @param rInit  valeur initiale de la variable
     */
    private getStartInterval;
    private CalcZero;
    /**
     * Searches the interval from <tt>lowerLimit</tt> to <tt>upperLimit</tt>
     * for a root (i.e., zero) of the function <tt>func</tt> with respect to
     * its first argument using Brent's method root-finding algorithm.
     *
     * Translated from zeroin.c in http://www.netlib.org/c/brent.shar.
     *
     * Copyright (c) 2012 Borgar Thorsteinsson <borgar@borgar.net>
     * MIT License, http://www.opensource.org/licenses/mit-license.php
     *
     * @param {function} func function for which the root is sought.
     * @param {number} lowerlimit the lower point of the interval to be searched.
     * @param {number} upperlimit the upper point of the interval to be searched.
     * @param {number} errorTol the desired accuracy (convergence tolerance).
     * @param {number} maxIter the maximum number of iterations.
     * @returns an estimate for the root within accuracy.
     *
     */
    private uniroot;
}
//# sourceMappingURL=dichotomie.d.ts.map