pimath 0.0.120 → 0.0.121

package/esm/maths/randomization/rndHelpers.js

@@ -1,77 +1,77 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rndHelpers = void 0;
-/**
- * Random helpers
- */
-const numeric_1 = require("../numeric");
-class rndHelpers {
-    /**
-     * Random boolean with a percent ratio
-     * @param percent
-     */
-    static randomBool(percent = 0.5) {
-        return Math.random() < percent;
-    }
-    /**
-     * Random integer between two values.
-     * @param a (number) : From this value to the second value. If the second is ommited, this value is the max value.
-     * @param b (number) : To this value. If this is ommited.
-     */
-    static randomInt(a, b) {
-        if (b === undefined) {
-            return this.randomInt(0, a);
-        }
-        return Math.floor(Math.random() * (b - a + 1) + a);
-    }
-    /**
-     * Random integer between -max and max value.
-     * @param max (number) : determine the limits.
-     * @param zero (bool) : determine if zero is allowed or not.
-     */
-    static randomIntSym(max, zero) {
-        if (zero === false) {
-            return this.randomBool() ? this.randomInt(1, max) : -this.randomInt(1, max);
-        }
-        else {
-            return this.randomInt(-max, max);
-        }
-    }
-    static randomPrime(max) {
-        let primes = numeric_1.Numeric.primes();
-        if (max !== undefined) {
-            primes = primes.filter(x => x < max);
-        }
-        return this.randomItem(primes);
-    }
-    static randomArray(arr, number) {
-        if (number === undefined) {
-            number = 1;
-        }
-        // Return a clone array
-        if (arr.length <= 0) {
-            return Object.values(arr);
-        }
-        // Randomize the array and return the n first elements.
-        return rndHelpers.shuffleArray(arr).slice(0, number);
-    }
-    static randomItem(arr) {
-        if (arr.length === 0) {
-            return '';
-        }
-        return this.randomArray(arr, 1)[0];
-    }
-    static shuffleArray(arr) {
-        // The Fisher-Yates algorithm
-        let shuffleArray = Object.values(arr);
-        for (let i = shuffleArray.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            const temp = shuffleArray[i];
-            shuffleArray[i] = shuffleArray[j];
-            shuffleArray[j] = temp;
-        }
-        return shuffleArray;
-    }
-}
-exports.rndHelpers = rndHelpers;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rndHelpers = void 0;
+/**
+ * Random helpers
+ */
+const numeric_1 = require("../numeric");
+class rndHelpers {
+    /**
+     * Random boolean with a percent ratio
+     * @param percent
+     */
+    static randomBool(percent = 0.5) {
+        return Math.random() < percent;
+    }
+    /**
+     * Random integer between two values.
+     * @param a (number) : From this value to the second value. If the second is ommited, this value is the max value.
+     * @param b (number) : To this value. If this is ommited.
+     */
+    static randomInt(a, b) {
+        if (b === undefined) {
+            return this.randomInt(0, a);
+        }
+        return Math.floor(Math.random() * (b - a + 1) + a);
+    }
+    /**
+     * Random integer between -max and max value.
+     * @param max (number) : determine the limits.
+     * @param zero (bool) : determine if zero is allowed or not.
+     */
+    static randomIntSym(max, zero) {
+        if (zero === false) {
+            return this.randomBool() ? this.randomInt(1, max) : -this.randomInt(1, max);
+        }
+        else {
+            return this.randomInt(-max, max);
+        }
+    }
+    static randomPrime(max) {
+        let primes = numeric_1.Numeric.primes();
+        if (max !== undefined) {
+            primes = primes.filter(x => x < max);
+        }
+        return this.randomItem(primes);
+    }
+    static randomArray(arr, number) {
+        if (number === undefined) {
+            number = 1;
+        }
+        // Return a clone array
+        if (arr.length <= 0) {
+            return Object.values(arr);
+        }
+        // Randomize the array and return the n first elements.
+        return rndHelpers.shuffleArray(arr).slice(0, number);
+    }
+    static randomItem(arr) {
+        if (arr.length === 0) {
+            return '';
+        }
+        return this.randomArray(arr, 1)[0];
+    }
+    static shuffleArray(arr) {
+        // The Fisher-Yates algorithm
+        let shuffleArray = Object.values(arr);
+        for (let i = shuffleArray.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            const temp = shuffleArray[i];
+            shuffleArray[i] = shuffleArray[j];
+            shuffleArray[j] = temp;
+        }
+        return shuffleArray;
+    }
+}
+exports.rndHelpers = rndHelpers;
 //# sourceMappingURL=rndHelpers.js.map

package/esm/maths/randomization/rndMonom.d.ts

@@ -1,12 +1,12 @@
-import { randomCore } from "./randomCore";
-import { randomMonomConfig } from "./rndTypes";
-import { Monom } from "../algebra/monom";
-/**
- * Create a random monom based on a based configuration
- */
-export declare class rndMonom extends randomCore {
-    protected _config: randomMonomConfig;
-    protected _defaultConfig: randomMonomConfig;
-    constructor(userConfig?: randomMonomConfig);
-    generate: () => Monom;
-}
+import { randomCore } from "./randomCore";
+import { randomMonomConfig } from "./rndTypes";
+import { Monom } from "../algebra/monom";
+/**
+ * Create a random monom based on a based configuration
+ */
+export declare class rndMonom extends randomCore {
+    protected _config: randomMonomConfig;
+    protected _defaultConfig: randomMonomConfig;
+    constructor(userConfig?: randomMonomConfig);
+    generate: () => Monom;
+}

package/esm/maths/randomization/rndMonom.js

@@ -1,53 +1,53 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rndMonom = void 0;
-const randomCore_1 = require("./randomCore");
-const random_1 = require("./random");
-const monom_1 = require("../algebra/monom");
-/**
- * Create a random monom based on a based configuration
- */
-class rndMonom extends randomCore_1.randomCore {
-    constructor(userConfig) {
-        super();
-        this.generate = () => {
-            // Create a monom instance
-            let M = new monom_1.Monom();
-            // Generate the coefficient
-            if (typeof this._config.fraction === "boolean") {
-                M.coefficient = random_1.Random.fraction({
-                    zero: this._config.zero,
-                    reduced: true,
-                    natural: !this._config.fraction
-                });
-            }
-            else {
-                M.coefficient = random_1.Random.fraction(this._config.fraction);
-            }
-            // Calculate the degree of the monom
-            if (this._config.letters.length > 1) {
-                // Initialise each items...
-                for (let L of this._config.letters.split('')) {
-                    M.setLetter(L, 0);
-                }
-                for (let i = 0; i < this._config.degree; i++) {
-                    const L = random_1.Random.item(this._config.letters.split(""));
-                    M.setLetter(L, M.degree(L).clone().add(1));
-                }
-            }
-            else {
-                M.setLetter(this._config.letters, this._config.degree);
-            }
-            return M;
-        };
-        this._defaultConfig = {
-            letters: 'x',
-            degree: 2,
-            fraction: true,
-            zero: false
-        };
-        this._config = this.mergeConfig(userConfig, this._defaultConfig);
-    }
-}
-exports.rndMonom = rndMonom;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rndMonom = void 0;
+const randomCore_1 = require("./randomCore");
+const random_1 = require("./random");
+const monom_1 = require("../algebra/monom");
+/**
+ * Create a random monom based on a based configuration
+ */
+class rndMonom extends randomCore_1.randomCore {
+    constructor(userConfig) {
+        super();
+        this.generate = () => {
+            // Create a monom instance
+            let M = new monom_1.Monom();
+            // Generate the coefficient
+            if (typeof this._config.fraction === "boolean") {
+                M.coefficient = random_1.Random.fraction({
+                    zero: this._config.zero,
+                    reduced: true,
+                    natural: !this._config.fraction
+                });
+            }
+            else {
+                M.coefficient = random_1.Random.fraction(this._config.fraction);
+            }
+            // Calculate the degree of the monom
+            if (this._config.letters.length > 1) {
+                // Initialise each items...
+                for (let L of this._config.letters.split('')) {
+                    M.setLetter(L, 0);
+                }
+                for (let i = 0; i < this._config.degree; i++) {
+                    const L = random_1.Random.item(this._config.letters.split(""));
+                    M.setLetter(L, M.degree(L).clone().add(1));
+                }
+            }
+            else {
+                M.setLetter(this._config.letters, this._config.degree);
+            }
+            return M;
+        };
+        this._defaultConfig = {
+            letters: 'x',
+            degree: 2,
+            fraction: true,
+            zero: false
+        };
+        this._config = this.mergeConfig(userConfig, this._defaultConfig);
+    }
+}
+exports.rndMonom = rndMonom;
 //# sourceMappingURL=rndMonom.js.map

package/esm/maths/randomization/rndPolynom.d.ts

@@ -1,13 +1,13 @@
-import { randomCore } from "./randomCore";
-import { randomPolynomConfig } from "./rndTypes";
-import { Polynom } from "../algebra/polynom";
-/**
- * Random polynoms
- */
-export declare class rndPolynom extends randomCore {
-    protected _config: randomPolynomConfig;
-    protected _defaultConfig: randomPolynomConfig;
-    constructor(userConfig?: randomPolynomConfig);
-    generate: () => Polynom;
-    factorable: () => Polynom;
-}
+import { randomCore } from "./randomCore";
+import { randomPolynomConfig } from "./rndTypes";
+import { Polynom } from "../algebra/polynom";
+/**
+ * Random polynoms
+ */
+export declare class rndPolynom extends randomCore {
+    protected _config: randomPolynomConfig;
+    protected _defaultConfig: randomPolynomConfig;
+    constructor(userConfig?: randomPolynomConfig);
+    generate: () => Polynom;
+    factorable: () => Polynom;
+}

package/esm/maths/randomization/rndPolynom.js

@@ -1,75 +1,75 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rndPolynom = void 0;
-const randomCore_1 = require("./randomCore");
-const rndMonom_1 = require("./rndMonom");
-const random_1 = require("./random");
-const polynom_1 = require("../algebra/polynom");
-/**
- * Random polynoms
- */
-class rndPolynom extends randomCore_1.randomCore {
-    constructor(userConfig) {
-        super();
-        this.generate = () => {
-            if (this._config.factorable && this._config.degree > 1) {
-                return this.factorable();
-            }
-            // Create the polynom
-            let P = new polynom_1.Polynom().empty(), M;
-            for (let i = this._config.degree; i >= 0; i--) {
-                // Create monom of corresponding degree.
-                M = new rndMonom_1.rndMonom({
-                    letters: this._config.letters,
-                    degree: i,
-                    fraction: this._config.fraction,
-                    zero: (i === this._config.degree) ? false : this._config.allowNullMonom
-                }).generate();
-                // If degree is the greatest and unit is true, set the monom value to one.
-                if (this._config.unit && this._config.degree === i) {
-                    M.coefficient.one();
-                }
-                // Add to the polynom
-                P.add(M);
-            }
-            // Make sure the first monom is positive.
-            if (this._config.positive && P.monomByDegree().coefficient.isNegative()) {
-                P.monomByDegree().coefficient.opposed();
-            }
-            // If the number of monoms is greater than the allowed value, remove some of them... except the first one !
-            if (this._config.numberOfMonoms > 0 && this._config.numberOfMonoms < P.length) {
-                // Get the greatest degree monom
-                let M = P.monomByDegree().clone();
-                P.monoms = random_1.Random.array(P.monoms.slice(1), this._config.numberOfMonoms - 1);
-                P.add(M).reorder().reduce();
-            }
-            return P;
-        };
-        this.factorable = () => {
-            let P = new polynom_1.Polynom().one();
-            let _factorableConfig = { ...this._config };
-            _factorableConfig.degree = 1;
-            _factorableConfig.factorable = false;
-            for (let i = 0; i < this._config.degree; i++) {
-                P.multiply(random_1.Random.polynom(_factorableConfig));
-            }
-            return P;
-        };
-        // Default config for a random polynom
-        this._defaultConfig = {
-            letters: 'x',
-            degree: 2,
-            fraction: false,
-            zero: false,
-            unit: false,
-            factorable: false,
-            allowNullMonom: true,
-            numberOfMonoms: 0,
-            positive: true
-        };
-        // Merge config with initialiser
-        this._config = this.mergeConfig(userConfig, this._defaultConfig);
-    }
-}
-exports.rndPolynom = rndPolynom;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rndPolynom = void 0;
+const randomCore_1 = require("./randomCore");
+const rndMonom_1 = require("./rndMonom");
+const random_1 = require("./random");
+const polynom_1 = require("../algebra/polynom");
+/**
+ * Random polynoms
+ */
+class rndPolynom extends randomCore_1.randomCore {
+    constructor(userConfig) {
+        super();
+        this.generate = () => {
+            if (this._config.factorable && this._config.degree > 1) {
+                return this.factorable();
+            }
+            // Create the polynom
+            let P = new polynom_1.Polynom().empty(), M;
+            for (let i = this._config.degree; i >= 0; i--) {
+                // Create monom of corresponding degree.
+                M = new rndMonom_1.rndMonom({
+                    letters: this._config.letters,
+                    degree: i,
+                    fraction: this._config.fraction,
+                    zero: (i === this._config.degree) ? false : this._config.allowNullMonom
+                }).generate();
+                // If degree is the greatest and unit is true, set the monom value to one.
+                if (this._config.unit && this._config.degree === i) {
+                    M.coefficient.one();
+                }
+                // Add to the polynom
+                P.add(M);
+            }
+            // Make sure the first monom is positive.
+            if (this._config.positive && P.monomByDegree().coefficient.isNegative()) {
+                P.monomByDegree().coefficient.opposed();
+            }
+            // If the number of monoms is greater than the allowed value, remove some of them... except the first one !
+            if (this._config.numberOfMonoms > 0 && this._config.numberOfMonoms < P.length) {
+                // Get the greatest degree monom
+                let M = P.monomByDegree().clone();
+                P.monoms = random_1.Random.array(P.monoms.slice(1), this._config.numberOfMonoms - 1);
+                P.add(M).reorder().reduce();
+            }
+            return P;
+        };
+        this.factorable = () => {
+            let P = new polynom_1.Polynom().one();
+            let _factorableConfig = { ...this._config };
+            _factorableConfig.degree = 1;
+            _factorableConfig.factorable = false;
+            for (let i = 0; i < this._config.degree; i++) {
+                P.multiply(random_1.Random.polynom(_factorableConfig));
+            }
+            return P;
+        };
+        // Default config for a random polynom
+        this._defaultConfig = {
+            letters: 'x',
+            degree: 2,
+            fraction: false,
+            zero: false,
+            unit: false,
+            factorable: false,
+            allowNullMonom: true,
+            numberOfMonoms: 0,
+            positive: true
+        };
+        // Merge config with initialiser
+        this._config = this.mergeConfig(userConfig, this._defaultConfig);
+    }
+}
+exports.rndPolynom = rndPolynom;
 //# sourceMappingURL=rndPolynom.js.map

package/esm/maths/randomization/rndTypes.d.ts

@@ -1,34 +1,34 @@
-import { Fraction } from "../coefficients/fraction";
-export type randomCoefficientConfig = {
-    negative?: boolean;
-    max?: number;
-    reduced?: boolean;
-    zero?: boolean;
-    natural?: boolean;
-};
-export type randomMonomConfig = {
-    letters?: string;
-    degree?: number;
-    fraction?: boolean | randomCoefficientConfig;
-    zero?: boolean;
-};
-export type randomPolynomConfig = randomMonomConfig & {
-    unit?: boolean;
-    factorable?: boolean;
-    allowNullMonom?: boolean;
-    numberOfMonoms?: number;
-    positive?: boolean;
-};
-export type randomGeometryLineConfig = {
-    A: {
-        x: number | Fraction;
-        y: number | Fraction;
-    };
-    slope?: Fraction | string | number;
-};
-export type randomGeometryPointConfig = {
-    quadrant?: number;
-    axis?: string | boolean;
-    fraction?: boolean;
-    max?: number;
-};
+import { Fraction } from "../coefficients/fraction";
+export type randomCoefficientConfig = {
+    negative?: boolean;
+    max?: number;
+    reduced?: boolean;
+    zero?: boolean;
+    natural?: boolean;
+};
+export type randomMonomConfig = {
+    letters?: string;
+    degree?: number;
+    fraction?: boolean | randomCoefficientConfig;
+    zero?: boolean;
+};
+export type randomPolynomConfig = randomMonomConfig & {
+    unit?: boolean;
+    factorable?: boolean;
+    allowNullMonom?: boolean;
+    numberOfMonoms?: number;
+    positive?: boolean;
+};
+export type randomGeometryLineConfig = {
+    A: {
+        x: number | Fraction;
+        y: number | Fraction;
+    };
+    slope?: Fraction | string | number;
+};
+export type randomGeometryPointConfig = {
+    quadrant?: number;
+    axis?: string | boolean;
+    fraction?: boolean;
+    max?: number;
+};

package/esm/maths/randomization/rndTypes.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=rndTypes.js.map

package/esm/maths/shutingyard.d.ts

@@ -1,59 +1,59 @@
-export type tokenType = {
-    [key: string]: {
-        precedence: number;
-        associative: string;
-        type: string;
-    };
-};
-export declare const tokenConstant: {
-    [Key: string]: number;
-};
-export declare enum ShutingyardType {
-    VARIABLE = "variable",
-    COEFFICIENT = "coefficient",
-    OPERATION = "operation",
-    CONSTANT = "constant",
-    FUNCTION = "function",
-    MONOM = "monom"
-}
-export declare enum ShutingyardMode {
-    EXPRESSION = "expression",
-    POLYNOM = "polynom",
-    SET = "set",
-    NUMERIC = "numeric"
-}
-export type Token = {
-    token: string;
-    tokenType: string;
-};
-export declare class Shutingyard {
-    readonly _mode: ShutingyardMode;
-    private _rpn;
-    private _tokenConfig;
-    private _tokenConstant;
-    private _tokenKeys;
-    private _uniformize;
-    constructor(mode?: ShutingyardMode);
-    get rpn(): Token[];
-    get rpnToken(): string[];
-    /**
-     * Determin if the token is a defined operation
-     * Defined operations: + - * / ^ sin cos tan
-     * @param token
-     */
-    tokenConfigInitialization(): tokenType;
-    /**
-     * Get the next token to analyse.
-     * @param expr (string) Expression to analyse
-     * @param start (number) CUrrent position in the expr string.
-     */
-    NextToken(expr: string, start: number): [string, number, string];
-    normalize(expr: string): string;
-    /**
-     * Parse an expression using the shutting yard tree algorithms
-     * @param expr (string) Expression to analyse
-     * Returns a RPN list of items.
-     * @param uniformize
-     */
-    parse(expr: string, uniformize?: boolean): Shutingyard;
-}
+export type tokenType = {
+    [key: string]: {
+        precedence: number;
+        associative: string;
+        type: string;
+    };
+};
+export declare const tokenConstant: {
+    [Key: string]: number;
+};
+export declare enum ShutingyardType {
+    VARIABLE = "variable",
+    COEFFICIENT = "coefficient",
+    OPERATION = "operation",
+    CONSTANT = "constant",
+    FUNCTION = "function",
+    MONOM = "monom"
+}
+export declare enum ShutingyardMode {
+    EXPRESSION = "expression",
+    POLYNOM = "polynom",
+    SET = "set",
+    NUMERIC = "numeric"
+}
+export type Token = {
+    token: string;
+    tokenType: string;
+};
+export declare class Shutingyard {
+    readonly _mode: ShutingyardMode;
+    private _rpn;
+    private _tokenConfig;
+    private _tokenConstant;
+    private _tokenKeys;
+    private _uniformize;
+    constructor(mode?: ShutingyardMode);
+    get rpn(): Token[];
+    get rpnToken(): string[];
+    /**
+     * Determin if the token is a defined operation
+     * Defined operations: + - * / ^ sin cos tan
+     * @param token
+     */
+    tokenConfigInitialization(): tokenType;
+    /**
+     * Get the next token to analyse.
+     * @param expr (string) Expression to analyse
+     * @param start (number) CUrrent position in the expr string.
+     */
+    NextToken(expr: string, start: number): [string, number, string];
+    normalize(expr: string): string;
+    /**
+     * Parse an expression using the shutting yard tree algorithms
+     * @param expr (string) Expression to analyse
+     * Returns a RPN list of items.
+     * @param uniformize
+     */
+    parse(expr: string, uniformize?: boolean): Shutingyard;
+}