pimath 0.0.24 → 0.0.28

package/src/maths/geometry/point.ts

@@ -2,15 +2,22 @@
  * Vector module contains everything necessary to handle 2d or 3d vectors.
  * @module Vector
  */
-import {Fraction} from "../coefficients/fraction";
+import {Fraction} from "../coefficients"
+
+/**
+ * Helper class - a way to identify an object {x: number, y: number}
+ */
+class PointXY {
+    public x: number
+    public y: number
+}
 
-//TODO: Ajouter une vérification si la droite existe.
 export class Point {
     private _x: Fraction;   // 1st component
     private _y: Fraction;   // 2nd component
     private _exist: Boolean;
 
-    constructor(...values: any) {
+    constructor(...values: unknown[]) {
         this._x = new Fraction().zero();
         this._y = new Fraction().zero();
 
@@ -21,10 +28,6 @@ export class Point {
         return this
     };
 
-    get isPoint() {
-        return true;
-    }
-
     // ------------------------------------------
     // Getter and setter
     // ------------------------------------------
@@ -66,7 +69,8 @@ export class Point {
     // Creation / parsing functions
     // ------------------------------------------
 
-    parse = (...values: any): Point => {
+
+    parse = (...values: unknown[]): Point => {
         // Initialize the value.
         this.zero();
 
@@ -81,30 +85,33 @@ export class Point {
             if (values[0] instanceof Point) {
                 this._x = values[0].x.clone()
                 this._y = values[0].y.clone()
-                return this;
+                return this
             }
 
             // Value is given as string, comma separated.
-            if(typeof values[0] === 'string'){
+            if (typeof values[0] === 'string') {
                 let xy = values[0].split(',')
-                if(xy.length===2){
+                if (xy.length === 2) {
                     this._x = new Fraction(xy[0]).reduce()
                     this._y = new Fraction(xy[1]).reduce()
-                    return this;
+                    return this
                 }
             }
 
             // Value given as an object with {x: value, y: value}
-            if (values[0].x !== undefined && values[0].y !== undefined) {
-                this._x = new Fraction(values[0].x).reduce()
-                this._y = new Fraction(values[0].y).reduce()
+            if(values[0] instanceof PointXY){
+                    this._x = new Fraction(values[0].x).reduce()
+                    this._y = new Fraction(values[0].y).reduce()
+                return this
             } else {
-                return this.zero();
+                return this.zero()
             }
         }
+
         if (values.length === 2) {
             this._x = new Fraction(values[0]).reduce()
             this._y = new Fraction(values[1]).reduce()
+            return this
         }
 
         return this;
@@ -140,8 +147,8 @@ export class Point {
     texValues = (numberOfDigits: number): string => {
         let pts = [];
 
-        pts.push(this._x.value.toFixed(numberOfDigits===undefined?2:numberOfDigits));
-        pts.push(this._y.value.toFixed(numberOfDigits===undefined?2:numberOfDigits));
+        pts.push(this._x.value.toFixed(numberOfDigits === undefined ? 2 : numberOfDigits));
+        pts.push(this._y.value.toFixed(numberOfDigits === undefined ? 2 : numberOfDigits));
 
         return `\\left(${pts.join(';')}\\right)`
     }

package/src/maths/geometry/triangle.ts

@@ -56,8 +56,6 @@ export class Triangle {
         return this;
     }
 
-    get isTriangle():boolean {return true;}
-
     // ------------------------------------------
     // Getter and setters
     // ------------------------------------------
@@ -158,7 +156,7 @@ export class Triangle {
             // - Three lines as text.
             if(values.filter((x:any) => typeof x === 'string').length===3) {
                 return this.parse( ...values.map((x:string) => new Line(x)) )
-            }else if(values.filter((x:any) => x.isLine === true).length===3) {
+            }else if(values.filter((x:any) => x instanceof Line).length===3) {
                 // We have three lines
                 this._lines = {
                     'AB': values[0],
@@ -187,7 +185,7 @@ export class Triangle {
                 }
             }else {
                 // At least, one of the value is not a point.
-                if (values.filter((x: any) => x.isPoint === true).length < 3) {
+                if (values.filter((x: any) => (x instanceof Point)).length < 3) {
                     return this.parse(
                         new Point(values[0]),
                         new Point(values[1]),
@@ -207,7 +205,7 @@ export class Triangle {
                 };
             }
         } else if (values.length === 1) {
-            if (values[0].isTriangle === true) {
+            if (values[0] instanceof Triangle) {
                 return values[0].clone();
             }
         }

package/src/maths/geometry/vector.ts

@@ -4,6 +4,7 @@
  */
 import {Fraction} from "../coefficients/fraction";
 import {Numeric} from "../numeric";
+import {Point} from "./point";
 
 export class Vector {
     private _x: Fraction;   // 1st component
@@ -73,7 +74,7 @@ export class Vector {
 
         if (values.length >= 2) {
             // Two points are given - skip the third value.
-            if (values[0].isPoint && values[1].isPoint) {
+            if (values[0] instanceof Point && values[1] instanceof Point) {
                 this._x = values[1].x.clone().subtract(values[0].x)
                 this._y = values[1].y.clone().subtract(values[0].y)
                 return this;
@@ -159,7 +160,7 @@ export class Vector {
 
     static scalarProduct = (v1: Vector, v2: Vector): number => {
         // TODO: Transform to fraction with nthroot.
-        return  v1.x.value * v2.x.value + v1.y.value * v2.y.value;
+        return v1.x.value * v2.x.value + v1.y.value * v2.y.value;
     };
 
     normal = (): Vector => {
@@ -180,7 +181,7 @@ export class Vector {
         return this;
     }
 
-    divideByScalar = (k:any): Vector => {
+    divideByScalar = (k: any): Vector => {
         return this.multiplyByScalar(new Fraction(k).invert());
     }
     // ------------------------------------------

package/src/maths/numexp.ts

@@ -0,0 +1,136 @@
+import {Shutingyard, ShutingyardMode, ShutingyardType, tokenConstant} from "./shutingyard";
+import {Fraction} from "./coefficients";
+
+export class NumExp {
+    private _rpn: { token: string, tokenType: string }[]
+    private _expression: string
+
+    constructor(value: string) {
+        this._expression = value
+        this._rpn = new Shutingyard(ShutingyardMode.NUMERIC).parse(value).rpn
+    }
+
+    get rpn(): { token: string; tokenType: string }[] {
+        return this._rpn;
+    }
+
+    get expression(): string {
+        return this._expression;
+    }
+
+    private _extractDecimalPart(value: number): string {
+        let decimal = value.toString()
+
+        if (!decimal.includes('.')) {
+            return ''
+        }
+
+        decimal = decimal.split('.')[1]
+
+        return decimal.substring(0, decimal.length - 2)
+    }
+
+    private _numberCorrection(value: number): number {
+        // Must modify the number if it's like:
+        // a: 3.0000000000000003
+        // b: 3.9999999999999994
+        // remove the last character
+        // check if around n last characters are either 0 or 9
+        // if it is, 'round' the number.
+
+        const epsilon = 0.00000000000001,
+            number_of_digits = 6
+
+        let decimal = this._extractDecimalPart(value)
+        if(decimal===''){return value}
+
+        const n9 = decimal.match(/9+$/g)
+        const n0 = decimal.match(/0+$/g)
+
+        if (n9 && n9[0].length >= number_of_digits) {
+            // New tested values.
+            let mod = this._extractDecimalPart(value + epsilon),
+                mod0 = mod.match(/0+$/g)
+
+            if(mod0 && mod0[0].length>= number_of_digits){
+                // The value can be changed. Remove all zeros!
+                return +((value+epsilon).toString().split(mod0[0])[0])
+            }
+        }
+
+        if (n0 && n0[0].length >= number_of_digits) {
+            // New tested values.
+            let mod = this._extractDecimalPart(value - epsilon),
+                mod9 = mod.match(/9+$/g)
+
+            if(mod9 && mod9[0].length>= number_of_digits){
+                // The value can be changed. Remove all nines!
+                return +(value.toString().split(n0[0])[0])
+            }
+        }
+
+        return value
+    }
+
+    private _addToStack(stack:number[], value: number): void {
+        stack.push(this._numberCorrection(value))
+    }
+
+    evaluate(values: { [Key: string]: number }): number {
+        let stack: number[] = []
+        for (const element of this._rpn) {
+            if (element.tokenType === ShutingyardType.COEFFICIENT) {
+                // May be a numeric value or a Fraction.
+                if (!isNaN(+element.token)) {
+                    this._addToStack(stack, +element.token)
+                } else {
+                    this._addToStack(stack, new Fraction(element.token).value)
+                }
+            } else if (element.tokenType === ShutingyardType.VARIABLE) {
+                if (values[element.token] !== undefined) {
+                    this._addToStack(stack, +values[element.token])
+                }
+            } else if (element.tokenType === ShutingyardType.CONSTANT) {
+                this._addToStack(stack, tokenConstant[element.token])
+            } else if (element.tokenType === 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 === 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
+        }
+    }
+}

package/src/maths/random/rndFraction.ts

@@ -15,6 +15,7 @@ export class rndFraction extends randomCore {
 
         this._defaultConfig = {
             negative: true,
+            max: 10,
             reduced: true,
             zero: true,
             natural: false
@@ -27,14 +28,14 @@ export class rndFraction extends randomCore {
         let Q = new Fraction()
 
         if(this._config.negative){
-            Q.numerator = Random.numberSym(10, this._config.zero)
+            Q.numerator = Random.numberSym(this._config.max, this._config.zero)
         }else {
-            Q.numerator = Random.number(this._config.zero ? 0 : 1, 10)
+            Q.numerator = Random.number(this._config.zero ? 0 : 1, this._config.max)
         }
         if(this._config.natural){
             Q.denominator = 1
         }else {
-            Q.denominator = Random.number(1, 10)
+            Q.denominator = Random.number(1, this._config.max)
         }
 
         return this._config.reduced?Q.reduce():Q

package/src/maths/random/rndMonom.ts

@@ -1,53 +1,57 @@
 import {randomCore} from "./randomCore";
-import {randomMonomConfig, randomPolynomConfig} from "./rndTypes";
+import {randomMonomConfig} from "./rndTypes";
 import {Random} from "./index";
-import {Monom} from "../algebra/monom";
+import {Monom} from "../algebra";
 
 /**
  * Create a random monom based on a based configuration
  */
-    export class rndMonom extends randomCore {
-        declare protected _config: randomMonomConfig
-        declare protected _defaultConfig: randomMonomConfig
-
-        constructor(userConfig?: randomMonomConfig) {
-            super();
-
-            this._defaultConfig = {
-                letters: 'x',
-                degree: 2,
-                fraction: true,
-                zero: false
-            }
-
-            this._config = this.mergeConfig(userConfig, this._defaultConfig)
+export class rndMonom extends randomCore {
+    declare protected _config: randomMonomConfig
+    declare protected _defaultConfig: randomMonomConfig
+
+    constructor(userConfig?: randomMonomConfig) {
+        super();
+
+        this._defaultConfig = {
+            letters: 'x',
+            degree: 2,
+            fraction: true,
+            zero: false
         }
 
-        generate = (): Monom => {
-            // Create a monom instance
-            let M = new Monom()
+        this._config = this.mergeConfig(userConfig, this._defaultConfig)
+    }
+
+    generate = (): Monom => {
+        // Create a monom instance
+        let M = new Monom()
 
-            // Generate the coefficient
+        // Generate the coefficient
+        if (typeof this._config.fraction === "boolean") {
             M.coefficient = Random.fraction({
                 zero: this._config.zero,
                 reduced: true,
                 natural: !this._config.fraction
             })
+        } else {
+            M.coefficient = 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.item(this._config.letters.split(""))
-                    M.setLetter(L, M.degree(L).clone().add(1))
-                }
-            } else {
-                M.setLetter(this._config.letters, this._config.degree)
+        // 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);
             }
-
-            return M
+            for (let i = 0; i < this._config.degree; i++) {
+                const L = 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
     }
+}

package/src/maths/random/rndPolynom.ts

@@ -24,7 +24,8 @@ export class rndPolynom extends randomCore {
             unit: false,
             factorable: false,
             allowNullMonom: true,
-            numberOfMonoms: 0
+            numberOfMonoms: 0,
+            positive: true
         }
 
         // Merge config with initialiser
@@ -39,6 +40,7 @@ export class rndPolynom extends randomCore {
         // Create the polynom
         let P = new Polynom().empty(),
             M: Monom
+
         for (let i = this._config.degree; i >= 0; i--) {
             // Create monom of corresponding degree.
             M = new rndMonom({
@@ -57,9 +59,17 @@ export class rndPolynom extends randomCore {
             P.add(M)
         }
 
-        // If the number of monoms is greater than the allowed value, remove some of them...
+        // 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) {
-            P.monoms = Random.array(P.monoms, this._config.numberOfMonoms)
+            // Get the greatest degree monom
+            let M = P.monomByDegree().clone()
+            P.monoms = Random.array(P.monoms.slice(1), this._config.numberOfMonoms-1)
+            P.add(M).reorder().reduce()
         }
         return P
     }

package/src/maths/random/rndTypes.ts

@@ -1,5 +1,6 @@
 export type randomCoefficientConfig = {
     negative?: boolean,
+    max?: number,
     reduced?: boolean,
     zero?:boolean,
     natural?:boolean
@@ -8,7 +9,7 @@ export type randomCoefficientConfig = {
 export type randomMonomConfig = {
     letters?: string,
     degree?: number,
-    fraction?: boolean,
+    fraction?: boolean|randomCoefficientConfig,
     zero?: boolean
 }
 
@@ -16,5 +17,6 @@ export type randomPolynomConfig = randomMonomConfig & {
     unit?: boolean,
     factorable?: boolean,
     allowNullMonom?: boolean,
-    numberOfMonoms?: number
+    numberOfMonoms?: number,
+    positive?: boolean
 }