pimath 0.0.119 → 0.0.121

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;
+}