jalhyd/build/base.js

JaLHyd, a Javascript Library for Hydraulics

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.capitalize = exports.formattedValue = exports.floatDivAndMod = exports.isGreaterThan = exports.isLowerThan = exports.isEqual = exports.isNumeric = exports.round = exports.BoolIdentity = exports.XOR = exports.Debug = void 0;
class Debug {
    /**
     * @param _DBG Flag de débuggage
     */
    constructor(_DBG) {
        this._DBG = _DBG;
    }
    /**
     * Affiche un message dans la console si le flag this.DBG est à true
     * @param s Message à afficher dans la console
     */
    debug(...args) {
        // tslint:disable-next-line:no-console
        if (this._DBG) {
            // tslint:disable-next-line:no-console
            console.log(...args);
        }
    }
    get DBG() {
        return this._DBG;
    }
    set DBG(d) {
        this._DBG = d;
    }
}
exports.Debug = Debug;
/**
 * Méthode simulant l'opérateur booléen xor
 * @see http://www.howtocreate.co.uk/xor.html
 */
function XOR(a, b) {
    return (a || b) && !(a && b);
}
exports.XOR = XOR;
/**
 * Méthode simulant l'opérateur booléen identité (vrai si a=b)
 */
function BoolIdentity(a, b) {
    return (a && b) || (!a && !b);
}
exports.BoolIdentity = BoolIdentity;
/**
 * arrondi d'un nombre avec une précision donnée
 * @param val nombre à arrondir
 * @param prec nombre de chiffres
 */
function round(val, prec) {
    const m = Math.pow(10, prec || 0);
    return Math.round(val * m) / m;
}
exports.round = round;
function isNumeric(s) {
    if (s !== undefined && s !== null) {
        if (typeof s === "string") {
            const trimmed = s.trim();
            return trimmed !== "" && !isNaN(Number(trimmed));
        }
        else if (typeof s === "number") {
            return !isNaN(s);
        }
    }
    return false;
}
exports.isNumeric = isNumeric;
/**
 * Retourne true si a et b sont égaux à e près (en gros)
 */
function isEqual(a, b, e = 1E-7) {
    if (a === 0 && b === 0) {
        return true;
    }
    if (b === 0) { // ne pas diviser par 0
        [a, b] = [b, a];
    }
    if (a === 0) { // éviter d'avoir un quotient toujours nul
        return (Math.abs(b) < e);
    }
    // cas général
    return (Math.abs((a / b) - 1) < e);
}
exports.isEqual = isEqual;
/** Retourne true si a < b à e près */
function isLowerThan(a, b, e = 1E-7) {
    return (b - a) > e; // enfin (a + e) < b quoi
}
exports.isLowerThan = isLowerThan;
/** Retourne true si a > b à e près */
function isGreaterThan(a, b, e = 1E-7) {
    return (a - b) > e;
}
exports.isGreaterThan = isGreaterThan;
/**
 * Division entière de a par b, plus modulo, avec une tolérance e
 * pour gérer le cas des nombres réels
 */
function floatDivAndMod(a, b, e = 1E-7) {
    let q = Math.floor(a / b);
    let r = a % b;
    // si le modulo est bon à un pouïème, pas de reste
    if (isEqual(r, b, e)) {
        r = 0;
        // si la division entière n'est pas tombée juste, +1 au quotient
        if (q !== (a / b)) {
            q++;
        }
    }
    // si le modulo est nul à un pouïème, il est nul
    if (isEqual(r, 0, e)) {
        r = 0;
    }
    return { q, r };
}
exports.floatDivAndMod = floatDivAndMod;
/**
 * Formats (rounds) the given number (or the value of the given parameter) with the
 * number of decimals specified in app preferences; if given number is too low and
 * more decimals would be needed, keep as much significative digits as the number of
 * decimals specified in app preferences, except potential trailing zeroes;
 * returns "-" to point out an error if value is not a number or is undefined
 *
 * ex. with 3 decimals:
 * 1             => 1.000
 * 65431         => 65431.000
 * 0.002         => 0.002
 * 0.00004521684 => 0.0000452
 * 0.000001      => 0.000001
 * 5.00004521684 => 5.000
 * 5.000001      => 5.000
 */
function formattedValue(value, nDigits) {
    // bulletproof
    nDigits = Math.max(nDigits, 1);
    nDigits = Math.min(nDigits, 100);
    if (typeof value !== "number" || value === undefined) {
        return "-";
    }
    const minRenderableNumber = Number("1E-" + nDigits);
    // if required precision is too low, avoid rendering only zeroes
    if (value < minRenderableNumber) {
        return String(Number(value.toPrecision(nDigits))); // double casting avoids trailing zeroes
    }
    else {
        return value.toFixed(nDigits);
    }
}
exports.formattedValue = formattedValue;
function capitalize(s) {
    return s.charAt(0).toUpperCase() + s.slice(1);
}
exports.capitalize = capitalize;
//# sourceMappingURL=base.js.map