pimath 0.0.13 → 0.0.17

package/src/maths/algebra/rational.ts

@@ -131,17 +131,17 @@ import {Fraction} from "../coefficients/fraction";
 
                 N.divide(D)
 
-                if (N.degree(letter) > 0) {
-                    return N.coefficient.sign() * (Math.pow((value > 0 ? 1 : -1), N.degree(letter) % 2)) === 1 ? Infinity : -Infinity
+                if (N.degree(letter).isStrictlyPositive()) {
+                    return N.coefficient.sign() * (Math.pow((value > 0 ? 1 : -1), N.degree(letter).value % 2)) === 1 ? Infinity : -Infinity
                 }
-                if (N.degree(letter) === 0) {
+                if (N.degree(letter).isZero()) {
                     return N.coefficient
                 }
-                if (N.degree(letter) > 0) {
-                    return N.coefficient.sign() * (Math.pow(-1, N.degree(letter) % 2)) === 1 ? 0 : -0
+                if (N.degree(letter).isStrictlyPositive()) {
+                    return N.coefficient.sign() * (Math.pow(-1, N.degree(letter).value % 2)) === 1 ? 0 : -0
                 }
             } else {
-                return this._numerator.evaluate({letter: value}).divide(this._denominator.evaluate({letter: value}))
+                return this._numerator.evaluate({letter: new Fraction(value)}).divide(this._denominator.evaluate({letter: new Fraction(value)}))
             }
         }
     }

package/src/maths/coefficients/fraction.ts

@@ -1,4 +1,5 @@
 import {Numeric} from "../numeric";
+import {Random} from "../random";
 
 export class Fraction {
     private _numerator: number;
@@ -95,8 +96,8 @@ export class Fraction {
                 S = value.split('/');
 
                 // Security checks
-                    if (S.length > 2) throw "Two many divide signs";
-                    if (S.map(x => x === '' || isNaN(Number(x))).includes(true)) throw "Not a number"
+                if (S.length > 2) throw "Two many divide signs";
+                if (S.map(x => x === '' || isNaN(Number(x))).includes(true)) throw "Not a number"
 
 
                 if (S.length === 1) {
@@ -193,18 +194,26 @@ export class Fraction {
         return this;
     };
 
-    add = (F: Fraction): Fraction => {
-        let N: number = this._numerator,
-            D: number = this._denominator;
+    add = (F: Fraction | number): Fraction => {
+        if (F instanceof Fraction) {
+            let N: number = this._numerator,
+                D: number = this._denominator;
 
-        this._numerator = N * F.denominator + F.numerator * D;
-        this._denominator = D * F.denominator;
+            this._numerator = N * F.denominator + F.numerator * D;
+            this._denominator = D * F.denominator;
+        }else{
+            return this.add(new Fraction(F))
+        }
 
         return this.reduce();
     };
 
-    subtract = (F: Fraction): Fraction => {
-        return this.add(F.clone().opposed());
+    subtract = (F: Fraction | number): Fraction => {
+        if (F instanceof Fraction) {
+            return this.add(F.clone().opposed());
+        } else {
+            return this.add(-F)
+        }
     };
 
     multiply = (F: Fraction | number): Fraction => {
@@ -241,10 +250,16 @@ export class Fraction {
 
         return this;
     }
-    pow = (p: number): Fraction => {
+    pow = (p: number | Fraction): Fraction => {
+        // TODO: Fraction.pow with a value different than a safe integer ?
+        if (p instanceof Fraction) {
+            return this.pow(p.value)
+        }
+
         if (!Number.isSafeInteger(p)) {
             return this.invalid();
         }
+
         this.reduce();
 
         if (p < 0) {
@@ -287,6 +302,32 @@ export class Fraction {
         return this;
     };
 
+
+    static max = (...fractions: (Fraction|number)[]): Fraction => {
+        let M = new Fraction(fractions[0])
+
+        for (let m of fractions) {
+            let compare = new Fraction(m)
+            if (compare.greater(M)) {
+                M = compare.clone()
+            }
+        }
+
+        return M
+    }
+    static min = (...fractions: (Fraction|number)[]): Fraction => {
+        let M = new Fraction(fractions[0])
+
+        for (let m of fractions) {
+            let compare = new Fraction(m)
+            if (compare.lesser(M)) {
+                M = compare.clone()
+            }
+        }
+
+        return M
+    }
+
     // ------------------------------------------
     // Mathematical operations specific to fractions
     // ------------------------------------------
@@ -319,49 +360,55 @@ export class Fraction {
      * @param F (Coefficient) The coefficient to compare
      * @param sign (string| default is =): authorized values: =, <, <=, >, >= with some variations.
      */
-    compare = (F: Fraction, sign?: string): boolean => {
+    compare = (F: unknown, sign?: string): boolean => {
         if (sign === undefined) {
             sign = '=';
         }
 
+        let compareFraction: Fraction
+        if (F instanceof Fraction) {
+            compareFraction = F.clone()
+        } else {
+            compareFraction = new Fraction(F)
+        }
 
         switch (sign) {
             case '>':
-                return this.value > F.value;
+                return this.value > compareFraction.value;
             case ">=" || "=>" || "geq":
-                return this.value >= F.value;
+                return this.value >= compareFraction.value;
             case "<":
-                return this.value < F.value;
+                return this.value < compareFraction.value;
             case "<=" || "=>" || "leq":
-                return this.value <= F.value;
+                return this.value <= compareFraction.value;
             case "=":
-                // let F2: Fraction = F.clone().reduce(),
+                // let F2: Fraction = compareFraction.clone().reduce(),
                 //     F1: Fraction = this.clone().reduce();
                 // return (F1.numerator === F2.numerator && F1.denominator === F2.denominator);
-                return this.value === F.value;
+                return this.value === compareFraction.value;
             case "<>":
-                return this.value !== F.value;
+                return this.value !== compareFraction.value;
             default:
                 return false;
         }
     };
     /* Compare shortcuts */
-    lesser = (than: Fraction): Boolean => {
+    lesser = (than: Fraction | number): Boolean => {
         return this.compare(than, '<');
     };
-    leq = (than: Fraction): Boolean => {
+    leq = (than: Fraction | number): Boolean => {
         return this.compare(than, '<=');
     };
-    greater = (than: Fraction): Boolean => {
+    greater = (than: Fraction | number): Boolean => {
         return this.compare(than, '>');
     };
-    geq = (than: Fraction): Boolean => {
+    geq = (than: Fraction | number): Boolean => {
         return this.compare(than, '>=');
     };
-    isEqual = (than: Fraction): boolean => {
+    isEqual = (than: Fraction | number): boolean => {
         return this.compare(than, '=');
     }
-    isDifferent = (than: Fraction): boolean => {
+    isNotEqual = (than: Fraction | number): boolean => {
         return this.compare(than, '<>');
     }
     isOpposed = (p: Fraction): boolean => {
@@ -373,14 +420,26 @@ export class Fraction {
     isZero = (): boolean => {
         return this._numerator === 0;
     }
+    isNotZero = (): boolean => {
+        return this._numerator !== 0;
+    }
     isOne = (): boolean => {
         return this._numerator === 1 && this._denominator === 1;
     }
+    isNegativeOne = (): boolean => {
+        return this._numerator === -1 && this._denominator === 1;
+    }
     isPositive = (): boolean => {
-        return this.sign()===1;
+        return this.sign() === 1;
     }
     isNegative = (): boolean => {
-        return this.sign()===-1;
+        return this.sign() === -1;
+    }
+    isStrictlyPositive = (): boolean => {
+        return this.value > 0
+    }
+    isStrictlyNegative = (): Boolean => {
+        return this.value < 0
     }
     isNaN = (): boolean => {
         return isNaN(this._numerator);
@@ -395,7 +454,19 @@ export class Fraction {
         return Math.sqrt(this._numerator) % 1 === 0 && Math.sqrt(this._denominator) % 1 === 0
     }
     isReduced = (): boolean => {
-        return Math.abs(Numeric.gcd(this._numerator, this._denominator))===1
+        return Math.abs(Numeric.gcd(this._numerator, this._denominator)) === 1
+    }
+    isNatural = (): boolean => {
+        return this.clone().reduce().denominator === 1
+    }
+    isRational = (): boolean => {
+        return !this.isNatural()
+    }
+    isEven = (): boolean => {
+        return this.isNatural() && this.value % 2 === 0
+    }
+    isOdd = (): boolean => {
+        return this.isNatural() && this.value % 2 === 1
     }
     sign = (): number => {
         return (this._numerator * this._denominator >= 0) ? 1 : -1;

package/src/maths/geometry/index.ts

@@ -2,4 +2,4 @@ export * from "./vector"
 export * from "./triangle"
 export * from "./point"
 export * from "./circle"
-export * from "./line"
+export * from "./line"

package/src/maths/geometry/line.ts

@@ -221,7 +221,7 @@ export class Line {
     // ------------------------------------------
     isParellelTo = (line: Line): Boolean => {
         // Do they have the isSame direction ?
-        return this.slope.isEqual(line.slope) && this.height.isDifferent(line.height);
+        return this.slope.isEqual(line.slope) && this.height.isNotEqual(line.height);
     }
     isSameAs = (line: Line): Boolean => {
         return this.slope.isEqual(line.slope) && this.height.isEqual(line.height);

package/src/maths/random/index.ts

@@ -1,17 +1,23 @@
 import {rndPolynom} from "./rndPolynom";
 import {rndMonom} from "./rndMonom";
 import {rndHelpers} from "./rndHelpers";
-import {randomMonomConfig, randomPolynomConfig} from "./rndTypes";
+import {randomCoefficientConfig, randomMonomConfig, randomPolynomConfig} from "./rndTypes";
 import {Monom, Polynom} from "../algebra";
+import {Fraction} from "../coefficients";
+import {rndFraction} from "./rndFraction";
 
 export * from "./rndTypes"
 export namespace Random {
     export function polynom(config?: randomPolynomConfig): Polynom {
-        return new rndPolynom(config).generate()
+        return (new rndPolynom(config)).generate()
     }
 
     export function monom(config?: randomMonomConfig): Monom {
-        return new rndMonom(config).generate()
+        return (new rndMonom(config)).generate()
+    }
+
+    export function fraction(config?: randomCoefficientConfig): Fraction {
+        return (new rndFraction(config)).generate()
     }
 
     export function number(from:number, to:number):number { return rndHelpers.randomInt(from,to)}

package/src/maths/random/rndFraction.ts

@@ -0,0 +1,37 @@
+import {randomCore} from "./randomCore";
+import {randomCoefficientConfig, randomMonomConfig, randomPolynomConfig} from "./rndTypes";
+import {Fraction} from "../coefficients";
+import {Random} from "./index";
+
+/**
+ * Create a random monom based on a based configuration
+ */
+export class rndFraction extends randomCore {
+    declare protected _config: randomCoefficientConfig
+    declare protected _defaultConfig: randomCoefficientConfig
+
+    constructor(userConfig?: randomCoefficientConfig) {
+        super();
+
+        this._defaultConfig = {
+            negative: true,
+            reduced: true,
+            zero: true
+        }
+
+        this._config = this.mergeConfig(userConfig, this._defaultConfig)
+    }
+
+    generate = (): Fraction => {
+        let Q = new Fraction()
+
+        if(this._config.negative){
+            Q.numerator = Random.numberSym(10, this._config.zero)
+        }else {
+            Q.numerator = Random.number(this._config.zero ? 0 : 1, 10)
+        }
+        Q.denominator = Random.number(1, 10)
+
+        return this._config.reduced?Q.reduce():Q
+    }
+}

package/src/maths/random/rndMonom.ts

@@ -8,7 +8,7 @@ import {Monom} from "../algebra/monom";
  */
     export class rndMonom extends randomCore {
         declare protected _config: randomMonomConfig
-        declare protected _defaultConfig: randomPolynomConfig
+        declare protected _defaultConfig: randomMonomConfig
 
         constructor(userConfig?: randomMonomConfig) {
             super();
@@ -28,7 +28,10 @@ import {Monom} from "../algebra/monom";
             let M = new Monom()
 
             // Generate the coefficient
-            M.coefficient.parse(Random.numberSym(10, this._config.zero), (this._config.fraction) ? Random.number(1, 10) : 1).reduce();
+            M.coefficient = Random.fraction({
+                zero: this._config.zero,
+                reduced: true
+            })
 
             // Calculate the degree of the monom
             if (this._config.letters.length > 1) {
@@ -38,7 +41,7 @@ import {Monom} from "../algebra/monom";
                 }
                 for (let i = 0; i < this._config.degree; i++) {
                     const L = Random.item(this._config.letters.split(""))
-                    M.setLetter(L, M.degree(L) + 1)
+                    M.setLetter(L, M.degree(L).clone().add(1))
                 }
             } else {
                 M.setLetter(this._config.letters, this._config.degree)

package/src/maths/random/rndPolynom.ts

@@ -2,8 +2,8 @@ import {randomCore} from "./randomCore";
 import {randomPolynomConfig} from "./rndTypes";
 import {rndMonom} from "./rndMonom";
 import {Random} from "./index";
-import {Polynom} from "../algebra/polynom";
-import {Monom} from "../algebra/monom";
+import {Polynom} from "../algebra";
+import {Monom} from "../algebra";
 
 /**
  * Random polynoms
@@ -32,10 +32,13 @@ export class rndPolynom extends randomCore {
     }
 
     generate = (): Polynom => {
+        if(this._config.factorable && this._config.degree>1){
+            return this.factorable()
+        }
+
         // 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({
@@ -56,14 +59,21 @@ export class rndPolynom extends randomCore {
 
         // If the number of monoms is greater than the allowed value, remove some of them...
         if (this._config.numberOfMonoms > 0 && this._config.numberOfMonoms < P.length) {
-            console.log(P.monoms.length)
             P.monoms = Random.array(P.monoms, this._config.numberOfMonoms)
         }
         return P
     }
 
     factorable = (): Polynom => {
-        let P = new Polynom()
+        let P = new Polynom().one()
+
+        let _factorableConfig = {...this._config}
+        _factorableConfig.degree = 1
+        _factorableConfig.factorable = false
+
+        for(let i=0; i<this._config.degree;i++){
+            P.multiply(Random.polynom(_factorableConfig))
+        }
 
         return P
     }

package/src/maths/random/rndTypes.ts

@@ -1,3 +1,8 @@
+export type randomCoefficientConfig = {
+    negative?: boolean,
+    reduced?: boolean,
+    zero?:boolean
+}
 
 export type randomMonomConfig = {
     letters?: string,

package/src/maths/shutingyard.ts

@@ -1,3 +1,5 @@
+import {loadHighlighter} from "typedoc/dist/lib/utils/highlighter";
+
 type tokenType = {
     [key: string]: {
         precedence: number,

package/tests/algebra/monom.test.ts

@@ -1,11 +1,32 @@
 import {expect} from 'chai';
-import {Monom} from "../../src/maths/algebra/monom";
+import {Monom} from "../../src/maths/algebra";
 import {Random} from "../../src/maths/random";
+import exp = require("constants");
 
-describe('Monom derivate and integrate', () => { // the tests container
-    it('derivate', () => { // the single test
+describe('Monom tests', ()=> {
+    it('parsing', ()=>{
+        const M0a = new Monom('3');
+        const M0b = new Monom('x');
+        const M1 = new Monom('3x^5');
+        const M2 = new Monom('2/3x^2yz^3y^4')
+        const M3 = new Monom('-3x^(-2)')
+        const M4 = new Monom('3x^(2/3)')
+        const M5 = new Monom('-3x^(-2/3)y^(-5)8x^3')
+
+        expect(M0a.tex).to.be.equal('3')
+        expect(M0b.tex).to.be.equal('x')
+        expect(M1.tex).to.be.equal('3x^{5}')
+        expect(M2.display).to.be.equal('2/3x^2y^5z^3')
+        expect(M3.tex).to.be.equal('-3x^{-2}')
+        expect(M4.tex).to.be.equal('3x^{2/3}')
+        expect(M5.tex).to.be.equal('-24x^{7/3}y^{-5}')
+    })
+
+    it('derivative', () => { // the single test
         const options = new Monom('7x^3'); // this will be your class
-        expect(options.derivative().tex).to.be.equal('21x^2');
+
+        expect(options.tex).to.be.equal('7x^{3}')
+        expect(options.derivative().tex).to.be.equal('21x^{2}');
     });
 
     it('integrate', () => { // the single test
@@ -13,15 +34,15 @@ describe('Monom derivate and integrate', () => { // the tests container
         expect(options.primitive().display).to.be.equal('7/4x^4');
     });
 
-    it('should create random Monom', function () {
+    it('randomize', function () {
         const M = Random.monom({
             letters: 'xyz',
             degree: 5,
             fraction: false,
-			zero: false
+            zero: false
         });
 
         expect(M.coefficient.isZero()).to.be.false
-        expect(M.degree()).to.be.greaterThan(0)
+        expect(M.degree().value).to.be.greaterThan(0)
     });
-});
+})

package/tests/algebra/polynom.test.ts

@@ -3,54 +3,45 @@ import {Fraction} from "../../src/maths/coefficients";
 import {Polynom} from "../../src/maths/algebra";
 import {Random} from "../../src/maths/random";
 
-describe('Polynom display', () => { // the tests container
-    it('Tex display', () => { // the single test
-        const options = new Polynom('x^2-2x+1'); // this will be your class
-        expect(options.tex).to.be.equal('x^2-2x+1');
+describe('Polynom tests', () => {
+    it('Parse polynom', () => {
+        const options = new Polynom('2x(x+3)^2(x-1)');
+        options.reorder().reduce();
+        expect(options.tex).to.be.equal('2x^{4}+10x^{3}+6x^{2}-18x');
     });
 
-    it('Parse polynom', () => { // the single test
-        const options = new Polynom('2x(x+3)^2(x-1)'); // this will be your class
-        options.reorder().reduce();
-        expect(options.tex).to.be.equal('2x^4+10x^3+6x^2-18x');
+    it('Tex display', () => {
+        const options = new Polynom('x^2-2x+1');
+        expect(options.tex).to.be.equal('x^{2}-2x+1');
     });
 
-    it('evaluate a polynom', function () {
+    it('Evaluate a polynom', function () {
         const P = new Polynom('2x-3')
 
         expect(P.evaluate(5).value).to.be.equal(7)
         expect(P.evaluate(new Fraction('5/3')).display).to.be.equal('1/3')
     });
-});
-
-describe('Polynom operation', () => {
-    it('Polynom are equals', () => {
+    it('Compare: equals', () => {
         let F = new Polynom('x+3'),
             Q = new Polynom('3+x'),
             P = new Polynom('x-3');
         expect(F.isEqual(Q)).to.be.true;
         expect(F.isEqual(P)).to.be.false;
     })
-});
-
-describe('Polynom integration', () => {
-    it('Polynom integrate', () => {
+    it('Integrate', () => {
         let F = new Polynom('2x^3-3x^2+x-3'),
             G = new Polynom('3/5x^2+4')
 
         expect(F.integrate(0, 2).value).to.be.equal(-4)
         expect(G.integrate(-3, 3).display).to.be.equal('174/5')
     })
-})
-
-describe('Polynom random creation', ()=>{
-    it('should create a random Polynom of degree 5', function () {
+    it('Random Polynom of degree 5', function () {
         let P = Random.polynom({
             degree: 6,
             numberOfMonoms: 3
         })
 
         expect(P.length).to.be.equal(3)
-        expect(P.degree()).to.be.lessThanOrEqual(6)
+        expect(P.degree().value).to.be.lessThanOrEqual(6)
     });
 })

package/tests/coefficients/fraction.test.ts

@@ -1,39 +1,36 @@
-import { expect } from 'chai';
-import {Fraction} from "../../src/maths/coefficients/fraction";
-import exp = require("constants");
-
-describe('Fraction display', () => { // the tests container
-	it('Tex display', () => { // the single test
-		const options = new Fraction(2, 5); // this will be your class
-		expect(options.frac).to.be.equal('\\frac{ 2 }{ 5 }');
-	});
-});
-
-describe('Fraction operation', () => {
-	it('Fraction are equals', ()=>{
-		let F = new Fraction(1,3),
-			Q = new Fraction(2, 6),
-			P = new Fraction(2, 5);
-		expect(F.isEqual(Q)).to.be.true;
-		expect(F.isEqual(P)).to.be.false;
-	})
-	it('Sum of two fraction', () => {
-		let F = new Fraction(1, 3),
-			Q = new Fraction(2,7);
-
-		F.add(Q);
-
-		expect(F.numerator).to.be.equal(13);
-		expect(F.denominator).to.be.equal(21);
-	})
-});
-
-describe('Fraction compare', () => {
-	it('Fraction is reduced', () => {
-		let F = new Fraction(2, 5),
-			Q = new Fraction(2, 6)
-
-		expect(F.isReduced()).to.be.true
-		expect(Q.isReduced()).to.be.false
-	})
+import {expect} from "chai";
+import {Fraction} from "../../src/maths/coefficients";
+
+describe('Fraction tests', () => { // the tests container
+
+    it('Tex display', () => { // the single test
+        const options = new Fraction(2, 5); // this will be your class
+        expect(options.frac).to.be.equal('\\frac{ 2 }{ 5 }');
+    });
+
+    it('Compare: equals', () => {
+        let F = new Fraction(1, 3),
+            Q = new Fraction(2, 6),
+            P = new Fraction(2, 5);
+        expect(F.isEqual(Q)).to.be.true;
+        expect(F.isEqual(P)).to.be.false;
+    })
+
+    it('Operation: sum of two fraction', () => {
+        let F = new Fraction(1, 3),
+            Q = new Fraction(2, 7);
+
+        F.add(Q);
+
+        expect(F.numerator).to.be.equal(13);
+        expect(F.denominator).to.be.equal(21);
+    })
+
+    it('Reduced', () => {
+        let F = new Fraction(2, 5),
+            Q = new Fraction(2, 6)
+
+        expect(F.isReduced()).to.be.true
+        expect(Q.isReduced()).to.be.false
+    })
 })

package/tests/shutingyard.test.ts

@@ -19,7 +19,6 @@ describe('Shuting yard', () => { // the tests container
         expect(SY3b.rpn.map(x=>x.token)).to.have.all.members(['3/2', 'x', '5', '+', '*'])
         expect(SY4.rpn.map(x=>x.token)).to.have.all.members(['3/2', 'x', '2', '^', '*', '5', 'x', '*',  'y', '*',  '-', '12', '-'])
         expect(SY5.rpn.map(x=>x.token)).to.have.all.members(['3/2', 'x', '0', '3', '-', '^', '*', '5', 'x', '*', 'y', '*', '-', '12', '-'])
-
         expect(SY6.rpn.map(x=>x.token)).to.have.all.members(['x', '3', '^', 'y', '2', '^', '*', 'z', '*'])
     })
 

package/tsconfig.json

@@ -13,7 +13,7 @@
   "compilerOptions": {
     "outDir": "./esm/",
     "noImplicitAny": true,
-    "module": "ESNext",
+    "module": "commonjs",
     "target": "esnext",
     "allowJs": true,
     "jsx": "react",