npm - pimath - Versions diffs - 0.0.26 → 0.0.27 - Mend

pimath 0.0.26 → 0.0.27

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (50) hide show

package/dev/index.html +8 -7
package/dev/pi.js +225 -94
package/dev/pi.js.map +1 -1
package/dist/pi.js +1 -1
package/dist/pi.js.map +1 -1
package/docs/assets/search.js +1 -1
package/docs/classes/algebra.Equation.html +9 -9
package/docs/classes/algebra.LinearSystem.html +1 -1
package/docs/classes/algebra.Logicalset.html +2 -2
package/docs/classes/algebra.Monom.html +45 -44
package/docs/classes/algebra.Polynom.html +9 -9
package/docs/classes/algebra.Rational.html +2 -2
package/docs/classes/coefficients.Fraction.html +6 -6
package/docs/classes/coefficients.Nthroot.html +1 -1
package/docs/classes/geometry.Circle.html +1 -1
package/docs/classes/geometry.Line.html +2 -2
package/docs/classes/geometry.Point.html +1 -1
package/docs/classes/geometry.Triangle.html +5 -5
package/docs/classes/geometry.Vector.html +1 -1
package/docs/classes/numeric.Numeric.html +5 -5
package/docs/classes/shutingyard.Shutingyard.html +5 -5
package/docs/interfaces/geometry.remarquableLines.html +1 -1
package/docs/modules/algebra.html +1 -1
package/docs/modules/random.Random.html +1 -1
package/docs/modules/random.html +1 -1
package/esm/main.js +2 -0
package/esm/main.js.map +1 -1
package/esm/maths/algebra/logicalset.js +1 -1
package/esm/maths/algebra/logicalset.js.map +1 -1
package/esm/maths/algebra/monom.d.ts +2 -1
package/esm/maths/algebra/monom.js +7 -1
package/esm/maths/algebra/monom.js.map +1 -1
package/esm/maths/algebra/rational.d.ts +1 -1
package/esm/maths/algebra/rational.js +2 -2
package/esm/maths/algebra/rational.js.map +1 -1
package/esm/maths/numexp.d.ts +11 -0
package/esm/maths/numexp.js +107 -0
package/esm/maths/numexp.js.map +1 -0
package/esm/maths/shutingyard.d.ts +21 -4
package/esm/maths/shutingyard.js +72 -74
package/esm/maths/shutingyard.js.map +1 -1
package/package.json +1 -1
package/src/main.ts +2 -0
package/src/maths/algebra/logicalset.ts +2 -2
package/src/maths/algebra/monom.ts +35 -22
package/src/maths/algebra/rational.ts +1 -1
package/src/maths/numexp.ts +127 -0
package/src/maths/shutingyard.ts +144 -94
package/tests/algebra/monom.test.ts +1 -1
package/tests/shutingyard.test.ts +3 -3

package/dev/index.html CHANGED Viewed

@@ -29,14 +29,16 @@
 </head>
 <body>
-<div x-data="dev()">
-    <template x-for="(item, index) of output" :key="index">
-        <div class="katex-left" x-html="`\\[${item}\\]`"></div>
-    </template>
-</div>
+<!--<div x-data="dev()">-->
+<!--    <template x-for="(item, index) of output" :key="index">-->
+<!--        <div class="katex-left" x-html="`\\[${item}\\]`"></div>-->
+<!--    </template>-->
+<!--</div>-->
 <script>
-	ex1()
+  let ne = new Pi.NumExp('x^2-2*x+3*y-8')
+	console.log(ne.evaluate({x: 5, y: 3}))
 	function dev () {
 		let output = []
@@ -224,7 +226,6 @@
 		]
 	}
 </script>
 </body>
 </html>

package/dev/pi.js CHANGED Viewed

@@ -664,9 +664,6 @@ class LinearSystem {
         }
         return this;
     }
-    get isLinearSystem() {
-        return true;
-    }
     get equations() {
         return this._equations;
     }
@@ -881,7 +878,7 @@ class Logicalset {
     }
     ;
     parse = (value) => {
-        this._rpn = new shutingyard_1.Shutingyard('set').parse(value).rpn;
+        this._rpn = new shutingyard_1.Shutingyard(shutingyard_1.ShutingyardMode.SET).parse(value).rpn;
         return this;
     };
     evaluate(tokenSets, reference) {
@@ -1039,7 +1036,7 @@ class Monom {
         return this._coefficient;
     }
     set coefficient(F) {
-        this._coefficient = F;
+        this._coefficient = new coefficients_1.Fraction(F);
     }
     get literal() {
         return this._literal;
@@ -1178,6 +1175,12 @@ class Monom {
         let d = this.display;
         return (d[0] !== '-' ? '+' : '') + d;
     }
+    get texWithSign() {
+        if (this.coefficient.isStrictlyPositive()) {
+            return '+' + this.tex;
+        }
+        return this.tex;
+    }
     get tex() {
         let L = '', letters = Object.keys(this._literal).sort();
         for (let letter of letters) {
@@ -1906,7 +1909,7 @@ class Polynom {
         const degreeP = P.degree(letter);
         let newM;
         let MaxIteration = this.degree(letter).clone().multiply(2);
-        while (reminder.degree(letter) >= degreeP && MaxIteration.isPositive()) {
+        while (reminder.degree(letter).geq(degreeP) && MaxIteration.isPositive()) {
             MaxIteration.subtract(1);
             newM = reminder.monomByDegree(undefined, letter).clone().divide(maxMP);
             if (newM.isZero()) {
@@ -2417,7 +2420,7 @@ exports.Polynom = Polynom;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Rational = void 0;
 const polynom_1 = __webpack_require__(/*! ./polynom */ "./src/maths/algebra/polynom.ts");
-const fraction_1 = __webpack_require__(/*! ../coefficients/fraction */ "./src/maths/coefficients/fraction.ts");
+const coefficients_1 = __webpack_require__(/*! ../coefficients */ "./src/maths/coefficients/index.ts");
 class Rational {
     _rawString;
     _numerator;
@@ -2516,7 +2519,7 @@ class Rational {
             }
         }
         else {
-            return this._numerator.evaluate({ letter: new fraction_1.Fraction(value) }).divide(this._denominator.evaluate({ letter: new fraction_1.Fraction(value) }));
+            return this._numerator.evaluate({ letter: new coefficients_1.Fraction(value) }).divide(this._denominator.evaluate({ letter: new coefficients_1.Fraction(value) }));
         }
     };
 }
@@ -4231,6 +4234,122 @@ class Numeric {
 exports.Numeric = Numeric;
+/***/ }),
+/***/ "./src/maths/numexp.ts":
+/*!*****************************!*\
+  !*** ./src/maths/numexp.ts ***!
+  \*****************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.NumExp = void 0;
+const shutingyard_1 = __webpack_require__(/*! ./shutingyard */ "./src/maths/shutingyard.ts");
+const coefficients_1 = __webpack_require__(/*! ./coefficients */ "./src/maths/coefficients/index.ts");
+class NumExp {
+    _rpn;
+    _expression;
+    constructor(value) {
+        this._expression = value;
+        this._rpn = new shutingyard_1.Shutingyard(shutingyard_1.ShutingyardMode.NUMERIC).parse(value).rpn;
+    }
+    _extractDecimalPart(value) {
+        let decimal = value.toString();
+        if (!decimal.includes('.')) {
+            return '';
+        }
+        decimal = decimal.split('.')[1];
+        return decimal.substring(0, decimal.length - 2);
+    }
+    _numberCorrection(value) {
+        const omega = 0.00000000000001, number_of_digits = 6;
+        let decimal = this._extractDecimalPart(value);
+        const n9 = decimal.match(/9+$/g);
+        const n0 = decimal.match(/0+$/g);
+        if (n9 && n9[0].length >= number_of_digits) {
+            let mod = this._extractDecimalPart(value + omega), mod0 = mod.match(/0+$/g);
+            if (mod0 && mod0[0].length >= number_of_digits) {
+                return +((value + omega).toString().split(mod0[0])[0]);
+            }
+        }
+        if (n0 && n0[0].length >= number_of_digits) {
+            let mod = this._extractDecimalPart(value - omega), mod9 = mod.match(/9+$/g);
+            if (mod9 && mod9[0].length >= number_of_digits) {
+                return +((value - omega).toString().split(mod9[0])[0]);
+            }
+        }
+        return value;
+    }
+    _addToStack(stack, value) {
+        stack.push(this._numberCorrection(value));
+    }
+    evaluate(values) {
+        let stack = [];
+        for (const element of this._rpn) {
+            if (element.tokenType === shutingyard_1.ShutingyardType.COEFFICIENT) {
+                if (!isNaN(+element.token)) {
+                    this._addToStack(stack, +element.token);
+                }
+                else {
+                    this._addToStack(stack, new coefficients_1.Fraction(element.token).value);
+                }
+            }
+            else if (element.tokenType === shutingyard_1.ShutingyardType.VARIABLE) {
+                if (values[element.token] !== undefined) {
+                    this._addToStack(stack, +values[element.token]);
+                }
+            }
+            else if (element.tokenType === shutingyard_1.ShutingyardType.CONSTANT) {
+                this._addToStack(stack, shutingyard_1.tokenConstant[element.token]);
+            }
+            else if (element.tokenType === shutingyard_1.ShutingyardType.OPERATION) {
+                if (element.token === '*') {
+                    const b = +stack.pop(), a = +stack.pop();
+                    this._addToStack(stack, a * b);
+                }
+                else if (element.token === '/') {
+                    const b = +stack.pop(), a = +stack.pop();
+                    this._addToStack(stack, a / b);
+                }
+                else if (element.token === '+') {
+                    const b = +stack.pop(), a = +stack.pop();
+                    this._addToStack(stack, a + b);
+                }
+                else if (element.token === '-') {
+                    const b = +stack.pop(), a = +stack.pop();
+                    this._addToStack(stack, a - b);
+                }
+                else if (element.token === '^') {
+                    const b = +stack.pop(), a = +stack.pop();
+                    this._addToStack(stack, Math.pow(a, b));
+                }
+            }
+            else if (element.tokenType === shutingyard_1.ShutingyardType.FUNCTION) {
+                const a = +stack.pop();
+                if (element.token === 'sin') {
+                    this._addToStack(stack, Math.sin(a));
+                }
+                else if (element.token === 'cos') {
+                    this._addToStack(stack, Math.cos(a));
+                }
+                else if (element.token === 'tan') {
+                    this._addToStack(stack, Math.tan(a));
+                }
+            }
+        }
+        if (stack.length === 1) {
+            return stack[0];
+        }
+        else {
+            console.error('There was a problem parsing', this._expression, '. The RPN array is', this._rpn);
+            return 0;
+        }
+    }
+}
+exports.NumExp = NumExp;
 /***/ }),
 /***/ "./src/maths/random/index.ts":
@@ -4348,6 +4467,7 @@ class rndFraction extends randomCore_1.randomCore {
         super();
         this._defaultConfig = {
             negative: true,
+            max: 10,
             reduced: true,
             zero: true,
             natural: false
@@ -4357,16 +4477,16 @@ class rndFraction extends randomCore_1.randomCore {
     generate = () => {
         let Q = new coefficients_1.Fraction();
         if (this._config.negative) {
-            Q.numerator = index_1.Random.numberSym(10, this._config.zero);
+            Q.numerator = index_1.Random.numberSym(this._config.max, this._config.zero);
         }
         else {
-            Q.numerator = index_1.Random.number(this._config.zero ? 0 : 1, 10);
+            Q.numerator = index_1.Random.number(this._config.zero ? 0 : 1, this._config.max);
         }
         if (this._config.natural) {
             Q.denominator = 1;
         }
         else {
-            Q.denominator = index_1.Random.number(1, 10);
+            Q.denominator = index_1.Random.number(1, this._config.max);
         }
         return this._config.reduced ? Q.reduce() : Q;
     };
@@ -4445,7 +4565,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.rndMonom = void 0;
 const randomCore_1 = __webpack_require__(/*! ./randomCore */ "./src/maths/random/randomCore.ts");
 const index_1 = __webpack_require__(/*! ./index */ "./src/maths/random/index.ts");
-const monom_1 = __webpack_require__(/*! ../algebra/monom */ "./src/maths/algebra/monom.ts");
+const algebra_1 = __webpack_require__(/*! ../algebra */ "./src/maths/algebra/index.ts");
 class rndMonom extends randomCore_1.randomCore {
     constructor(userConfig) {
         super();
@@ -4458,12 +4578,17 @@ class rndMonom extends randomCore_1.randomCore {
         this._config = this.mergeConfig(userConfig, this._defaultConfig);
     }
     generate = () => {
-        let M = new monom_1.Monom();
-        M.coefficient = index_1.Random.fraction({
-            zero: this._config.zero,
-            reduced: true,
-            natural: !this._config.fraction
-        });
+        let M = new algebra_1.Monom();
+        if (typeof this._config.fraction === "boolean") {
+            M.coefficient = index_1.Random.fraction({
+                zero: this._config.zero,
+                reduced: true,
+                natural: !this._config.fraction
+            });
+        }
+        else {
+            M.coefficient = index_1.Random.fraction(this._config.fraction);
+        }
         if (this._config.letters.length > 1) {
             for (let L of this._config.letters.split('')) {
                 M.setLetter(L, 0);
@@ -4508,7 +4633,8 @@ class rndPolynom extends randomCore_1.randomCore {
             unit: false,
             factorable: false,
             allowNullMonom: true,
-            numberOfMonoms: 0
+            numberOfMonoms: 0,
+            positive: true
         };
         this._config = this.mergeConfig(userConfig, this._defaultConfig);
     }
@@ -4529,8 +4655,13 @@ class rndPolynom extends randomCore_1.randomCore {
             }
             P.add(M);
         }
+        if (this._config.positive && P.monomByDegree().coefficient.isNegative()) {
+            P.monomByDegree().coefficient.opposed();
+        }
         if (this._config.numberOfMonoms > 0 && this._config.numberOfMonoms < P.length) {
-            P.monoms = index_1.Random.array(P.monoms, this._config.numberOfMonoms);
+            let M = P.monomByDegree().clone();
+            P.monoms = index_1.Random.array(P.monoms.slice(1), this._config.numberOfMonoms - 1);
+            P.add(M).reorder().reduce();
         }
         return P;
     };
@@ -4570,46 +4701,75 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Shutingyard = void 0;
+exports.Shutingyard = exports.ShutingyardMode = exports.ShutingyardType = exports.tokenConstant = void 0;
+exports.tokenConstant = {
+    pi: Math.PI,
+    e: Math.exp(1)
+};
+var ShutingyardType;
+(function (ShutingyardType) {
+    ShutingyardType["VARIABLE"] = "variable";
+    ShutingyardType["COEFFICIENT"] = "coefficient";
+    ShutingyardType["OPERATION"] = "operation";
+    ShutingyardType["CONSTANT"] = "constant";
+    ShutingyardType["FUNCTION"] = "function";
+    ShutingyardType["MONOM"] = "monom";
+})(ShutingyardType = exports.ShutingyardType || (exports.ShutingyardType = {}));
+var ShutingyardMode;
+(function (ShutingyardMode) {
+    ShutingyardMode["POLYNOM"] = "polynom";
+    ShutingyardMode["SET"] = "set";
+    ShutingyardMode["NUMERIC"] = "numeric";
+})(ShutingyardMode = exports.ShutingyardMode || (exports.ShutingyardMode = {}));
 class Shutingyard {
     _rpn = [];
     _mode;
     _tokenConfig;
+    _tokenConstant;
     _uniformize;
+    _tokenKeys;
     constructor(mode) {
-        this._mode = typeof mode === 'undefined' ? 'polynom' : mode;
+        this._mode = typeof mode === 'undefined' ? ShutingyardMode.POLYNOM : mode;
         this.tokenConfigInitialization();
     }
-    isOperation(token) {
-        if (token[0].match(/[+\-*/^]/g)) {
-            return true;
-        }
-        return false;
-    }
     tokenConfigInitialization() {
-        if (this._mode === 'set') {
+        if (this._mode === ShutingyardMode.SET) {
             this._tokenConfig = {
-                '&': { precedence: 3, associative: 'left' },
-                '|': { precedence: 3, associative: 'left' },
-                '!': { precedence: 4, associative: 'right' },
-                '-': { precedence: 2, associative: 'left' }
+                '&': { precedence: 3, associative: 'left', type: ShutingyardType.OPERATION },
+                '|': { precedence: 3, associative: 'left', type: ShutingyardType.OPERATION },
+                '!': { precedence: 4, associative: 'right', type: ShutingyardType.OPERATION },
+                '-': { precedence: 2, associative: 'left', type: ShutingyardType.OPERATION }
             };
             this._uniformize = false;
         }
+        else if (this._mode === ShutingyardMode.NUMERIC) {
+            this._tokenConfig = {
+                '^': { precedence: 4, associative: 'right', type: ShutingyardType.OPERATION },
+                '*': { precedence: 3, associative: 'left', type: ShutingyardType.OPERATION },
+                '/': { precedence: 3, associative: 'left', type: ShutingyardType.OPERATION },
+                '+': { precedence: 2, associative: 'left', type: ShutingyardType.OPERATION },
+                '-': { precedence: 2, associative: 'left', type: ShutingyardType.OPERATION },
+                '%': { precedence: 3, associative: 'right', type: ShutingyardType.OPERATION },
+                'sin': { precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION },
+                'cos': { precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION },
+                'tan': { precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION },
+            };
+        }
         else {
             this._tokenConfig = {
-                '^': { precedence: 4, associative: 'right' },
-                '*': { precedence: 3, associative: 'left' },
-                '/': { precedence: 3, associative: 'left' },
-                '+': { precedence: 2, associative: 'left' },
-                '-': { precedence: 2, associative: 'left' },
-                '%': { precedence: 3, associative: 'right' },
-                'sin': { precedence: 4, associative: 'right' },
-                'cos': { precedence: 4, associative: 'right' },
-                'tab': { precedence: 4, associative: 'right' },
+                '^': { precedence: 4, associative: 'right', type: ShutingyardType.OPERATION },
+                '*': { precedence: 3, associative: 'left', type: ShutingyardType.OPERATION },
+                '/': { precedence: 3, associative: 'left', type: ShutingyardType.OPERATION },
+                '+': { precedence: 2, associative: 'left', type: ShutingyardType.OPERATION },
+                '-': { precedence: 2, associative: 'left', type: ShutingyardType.OPERATION },
+                '%': { precedence: 3, associative: 'right', type: ShutingyardType.OPERATION },
+                'sin': { precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION },
+                'cos': { precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION },
+                'tan': { precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION },
             };
             this._uniformize = true;
         }
+        this._tokenKeys = Object.keys(this._tokenConfig).sort((a, b) => b.length - a.length);
         return this._tokenConfig;
     }
     NextToken2(expr, start) {
@@ -4629,75 +4789,43 @@ class Shutingyard {
             tokenType = 'function-argument';
         }
         else {
-            const keys = Object.keys(this._tokenConfig).sort((a, b) => b.length - a.length);
-            for (let key of keys) {
-                if (expr.substr(start, key.length) === key) {
+            for (let key of this._tokenKeys) {
+                if (expr.substring(start, start + key.length) === key) {
+                    token += key;
+                    tokenType = this._tokenConfig[key].type;
+                    break;
+                }
+            }
+            for (let key in exports.tokenConstant) {
+                if (expr.substring(start, start + key.length) === key) {
                     token += key;
-                    tokenType = 'operation';
+                    tokenType = ShutingyardType.CONSTANT;
                     break;
                 }
             }
             if (token === '') {
                 if (expr[start].match(/[0-9]/)) {
-                    token = expr.substr(start).match(/^([0-9.,/]+)/)[0];
-                    tokenType = 'coefficient';
+                    if (this._mode === ShutingyardMode.POLYNOM) {
+                        token = expr.substring(start).match(/^([0-9.,/]+)/)[0];
+                    }
+                    else {
+                        token = expr.substring(start).match(/^([0-9.,]+)/)[0];
+                    }
+                    tokenType = ShutingyardType.COEFFICIENT;
                 }
                 else if (expr[start].match(/[a-zA-Z]/)) {
-                    token = expr.substr(start).match(/^([a-zA-Z])/)[0];
-                    tokenType = 'variable';
+                    token = expr.substring(start).match(/^([a-zA-Z])/)[0];
+                    tokenType = ShutingyardType.VARIABLE;
                 }
                 else {
                     console.log('Unidentified token', expr[start], expr, start);
                     token = expr[start];
-                    tokenType = 'monom';
+                    tokenType = ShutingyardType.MONOM;
                 }
             }
         }
         return [token, start + token.length, tokenType];
     }
-    NextToken(expr, start) {
-        let tokenMatch, token, tokenType;
-        this.NextToken2(expr, start);
-        tokenMatch = (expr.substr(start).match(/^[0-9/a-zA-Z^]+/g)) || [];
-        if (expr.substr(start, start + 3).match(/^(sin|cos|tan)/g)) {
-            token = expr.substr(start, 3);
-            tokenType = 'function';
-        }
-        else if (tokenMatch.length > 0) {
-            token = tokenMatch[0];
-            tokenType = 'monom';
-        }
-        else if (expr[start].match(/[+\-*/^]/g)) {
-            token = expr[start];
-            tokenType = 'operation';
-        }
-        else if (expr[start].match(/[&|!]/g)) {
-            token = expr[start];
-            tokenType = 'operation';
-        }
-        else if (expr[start] === '(') {
-            token = '(';
-            tokenType = '(';
-        }
-        else if (expr[start] === ')') {
-            token = ')';
-            tokenType = ')';
-        }
-        else if (expr[start] === ',') {
-            token = ',';
-            tokenType = 'function-argument';
-        }
-        else {
-            token = tokenMatch[0];
-            tokenType = 'monom';
-            if (token === '') {
-                token = expr[start];
-                tokenType = 'monom';
-                console.log('SHUTING YARD - NEXT TOKEN: error at ', start);
-            }
-        }
-        return [token, start + token.length, tokenType];
-    }
     Uniformizer(expr) {
         if (!this._uniformize) {
             return expr;
@@ -4730,6 +4858,7 @@ class Shutingyard {
                 case 'monom':
                 case 'coefficient':
                 case 'variable':
+                case 'constant':
                     outQueue.push({
                         token,
                         tokenType
@@ -4842,6 +4971,7 @@ var exports = __webpack_exports__;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const numeric_1 = __webpack_require__(/*! ./maths/numeric */ "./src/maths/numeric.ts");
+const numexp_1 = __webpack_require__(/*! ./maths/numexp */ "./src/maths/numexp.ts");
 const shutingyard_1 = __webpack_require__(/*! ./maths/shutingyard */ "./src/maths/shutingyard.ts");
 const random_1 = __webpack_require__(/*! ./maths/random */ "./src/maths/random/index.ts");
 const coefficients_1 = __webpack_require__(/*! ./maths/coefficients */ "./src/maths/coefficients/index.ts");
@@ -4850,6 +4980,7 @@ const geometry_1 = __webpack_require__(/*! ./maths/geometry */ "./src/maths/geom
 window.Pi = {
     ShutingYard: shutingyard_1.Shutingyard,
     Numeric: numeric_1.Numeric,
+    NumExp: numexp_1.NumExp,
     Fraction: coefficients_1.Fraction,
     Root: coefficients_1.Nthroot,
     Monom: algebra_1.Monom,