pimath 0.0.14 → 0.0.18

package/src/maths/geometry/line.ts

@@ -2,12 +2,17 @@
  * This class works for 2d line in a plane.
  */
 
-import {Fraction} from "../coefficients/fraction";
+import {Fraction} from "../coefficients";
 import {Vector} from "./vector";
 import {Point} from "./point";
-import {Polynom} from "../algebra/polynom";
+import {Equation, Polynom} from "../algebra";
 import {Numeric} from "../numeric";
-import {Equation} from "../algebra/equation";
+
+enum LinePropriety {
+    None,
+    Parallel,
+    Perpendicular
+}
 
 export class Line {
     // A line is defined as the canonical form
@@ -20,19 +25,30 @@ export class Line {
     private _n: Vector;
     private _exists: boolean
 
+    private _referencePropriety: LinePropriety
+    private _referenceLine: Line
+
+    static PERPENDICULAR = LinePropriety.Perpendicular
+    static PARALLEL = LinePropriety.Parallel
+
     constructor(...values: any) {
 
         this._exists = false;
 
-        if (values !== undefined) {
+        if (values.length > 0) {
             this.parse(...values);
         }
 
         return this;
     }
 
-    get isLine():boolean {return true;}
-    get exists(): boolean {return this._exists; }
+    get isLine(): boolean {
+        return true;
+    }
+
+    get exists(): boolean {
+        return this._exists;
+    }
 
     // ------------------------------------------
     // Getter and setter
@@ -40,6 +56,7 @@ export class Line {
     get equation(): Equation {
         return new Equation(new Polynom().parse('xy', this._a, this._b, this._c), new Polynom('0')).simplify();
     }
+
     get tex(): { canonical: string, mxh: string, parametric: string } {
         // canonical    =>  ax + by + c = 0
         // mxh          =>  y = -a/b x - c/b
@@ -47,7 +64,7 @@ export class Line {
 
         let canonical = this.equation;
         // Make sur the first item is positive.
-        if(this._a.isNegative()){
+        if (this._a.isNegative()) {
             canonical.multiply(-1);
         }
 
@@ -102,6 +119,10 @@ export class Line {
         return new Vector(this._a, this._b);
     }
 
+    get director(): Vector {
+        return this._d.clone()
+    }
+
     set d(value: Vector) {
         this._d = value;
     }
@@ -117,61 +138,96 @@ export class Line {
 // ------------------------------------------
     // Creation / parsing functions
     // ------------------------------------------
-    parse = (...values: any): Line => {
+    /**
+     * Parse data to a line
+     * @param {any} values
+     * @returns {Line}
+     */
+    parse = (...values: unknown[]): Line => {
         this._exists = false;
 
-        if (values.length === 3) {
-            return this.parseByCoefficient(values[0], values[1], values[2]);
-        } else if (values.length === 2) {
-            if (values[0].isPoint && values[1].isVector) {
+        // Nothing is given...
+        if (values.length === 0) {
+            return this
+        }
+
+        // One value only: already a line (clone it), an Equation, a string (as Equation)
+        if (values.length === 1) {
+            if (values[0] instanceof Line) {
+                // Already a Line
+                return values[0].clone()
+            } else if (values[0] instanceof Equation) {
+                // It's an Equation
+                return this.parseEquation(values[0])
+            } else if (typeof values[0] === "string") {
+                // It's a string - create an Equation from it.
+                try {
+                    let E = new Equation(values[0])
+                    return this.parse(E)
+                } catch (e) {
+                    return this
+                }
+            }
+        }
+
+        if (values.length === 2) {
+            if (values[0] instanceof Point && values[1] instanceof Vector) {
                 return this.parseByPointAndVector(values[0], values[1]);
-            } else if (values[0].isPoint && values[1].isPoint) {
+            } else if (values[0] instanceof Point && values[1] instanceof Point) {
                 return this.parseByPointAndVector(values[0], new Vector(values[0], values[1]));
+            } else if (values[0] instanceof Vector && values[1] instanceof Point) {
+                return this.parseByPointAndNormal(values[1], values[0])
             }
-        } else if (values.length === 1){
-            // It's a already a line - clone it !
-            if(values[0].isLine){
-                return values[0].clone();
-            }
+        }
 
-            // Maybe it's a string or an equation
-            let equ = new Equation(values[0]);
-            if(equ.isEquation){
-                // Check if it's a valid equation.
-                equ.reorder(true)
+        if (values.length === 3) {
+            if (
+                (values[0] instanceof Fraction || typeof values[0] === 'number')
+                &&
+                (values[1] instanceof Fraction || typeof values[1] === 'number')
+                &&
+                (values[2] instanceof Fraction || typeof values[2] === 'number')
+            ) {
+                return this.parseByCoefficient(values[0], values[1], values[2]);
+            }
+        }
 
-                // It must contain either x, y or both.
-                let letters = new Set(equ.letters());
+        // TODO: Add the ability to create line from a normal vector
+        console.log('Someting wrong happend while creating the line')
+        return this;
+    }
 
-                // No 'x', no 'y' in the equations
-                if(!(letters.has('x') || letters.has('y'))){return;}
+    parseEquation = (equ: Equation): Line => {
+        // Reorder the eequation
+        equ.reorder(true)
 
-                // Another letter in the equation.
-                for(let elem of ['x', 'y']){
-                    if(letters.has(elem)){
-                        letters.delete(elem)}
-                }
+        // It must contain either x, y or both.
+        let letters = new Set(equ.letters());
 
-                if(letters.size>0){
-                    console.log('Extra variable in the equation.')
-                    return this;
-                }
+        // No 'x', no 'y' in the equations
+        if (!(letters.has('x') || letters.has('y'))) {
+            return this
+        }
 
-                // Everything should be ok now...
-                return this.parseByCoefficient(equ.left.monomByLetter('x').coefficient, equ.left.monomByLetter('y').coefficient, equ.left.monomByDegree(0).coefficient)
+        // Another letter in the equation ?
+        for (let elem of ['x', 'y']) {
+            if (letters.has(elem)) {
+                letters.delete(elem)
             }
         }
-        // TODO: Add the ability to create line from a normal vector
-        console.log('Someting wrong happend while creating the line')
-        return this;
-    }
 
-    parseByCoefficient = (a: Fraction, b: Fraction, c: Fraction): Line => {
+        if (letters.size > 0) {
+            return this
+        }
+
+        // Everything should be ok now...
+        return this.parseByCoefficient(equ.left.monomByLetter('x').coefficient, equ.left.monomByLetter('y').coefficient, equ.left.monomByDegree(0).coefficient)
+    }
+    parseByCoefficient = (a: Fraction | number, b: Fraction | number, c: Fraction | number): Line => {
         this._a = new Fraction(a);
         this._b = new Fraction(b);
         this._c = new Fraction(c);
 
-        // TODO: initialize direction and reference point
         this._d = new Vector(this._b.clone(), this._a.clone().opposed());
         this._OA = new Point(new Fraction().zero(), this._c.clone());
         this._n = this._d.clone().normal();
@@ -205,6 +261,31 @@ export class Line {
         return this;
     }
 
+    parseByPointAndNormal = (P: Point, n: Vector): Line => {
+        return this.parseByCoefficient(
+            n.x,
+            n.y,
+            P.x.clone().multiply(n.x)
+                .add(P.y.clone().multiply(n.y)).opposed()
+        )
+    }
+
+    parseByPointAndLine = (P: Point, L: Line, orientation?: LinePropriety): Line => {
+
+        if (orientation === undefined) {
+            orientation = LinePropriety.Parallel
+        }
+
+        if (orientation === LinePropriety.Parallel) {
+            return this.parseByPointAndNormal(P, L.normal)
+        } else if (orientation === LinePropriety.Perpendicular) {
+            return this.parseByPointAndNormal(P, L.director)
+        }
+
+        this._exists = false
+        return this
+    }
+
     clone = (): Line => {
         this._a = this._a.clone();
         this._b = this._b.clone();
@@ -214,6 +295,7 @@ export class Line {
         this._OA = this._OA.clone();
         this._n = this._n.clone();
 
+        this._exists = this.exists
         return this;
     }
     // ------------------------------------------
@@ -221,7 +303,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);
@@ -320,7 +402,7 @@ export class Line {
         )
 
         // There is an intersection point
-        if(iPt.hasIntersection) {
+        if (iPt.hasIntersection) {
             return iPt.point.x.value >= Math.min(A.x.value, B.x.value)
                 && iPt.point.x.value <= Math.max(A.x.value, B.x.value)
                 && iPt.point.y.value >= Math.min(A.y.value, B.y.value)
@@ -328,36 +410,41 @@ export class Line {
         }
         return false;
     }
+
     // ------------------------------------------
     // Special functions
     // ------------------------------------------
-    canonicalAsFloatCoefficient(decimals: number): string{
-        if(decimals===undefined){
+    canonicalAsFloatCoefficient(decimals: number): string {
+        if (decimals === undefined) {
             decimals = 2;
         }
 
         let ca = this._a.value,
             cb = this._b.value,
-            cc= this._c.value,
+            cc = this._c.value,
             canonical = '';
 
-        if(!this._a.isZero()){
-            if(this._a.isOne()){
+        if (!this._a.isZero()) {
+            if (this._a.isOne()) {
                 canonical = 'x'
-            }else if(this._a.clone().opposed().isOne()){
+            } else if (this._a.clone().opposed().isOne()) {
                 canonical = '-x'
-            }else{
-                canonical = this._a.value.toFixed(decimals)+'x'
+            } else {
+                canonical = this._a.value.toFixed(decimals) + 'x'
             }
         }
 
-        if(!this._b.isZero()){
-            if(this._b.isPositive()){canonical+='+'}
+        if (!this._b.isZero()) {
+            if (this._b.isPositive()) {
+                canonical += '+'
+            }
             canonical += this._b.value.toFixed(decimals) + 'y'
         }
 
-        if(!this._c.isZero()){
-            if(this._c.isPositive()){canonical+='+'}
+        if (!this._c.isZero()) {
+            if (this._c.isPositive()) {
+                canonical += '+'
+            }
             canonical += this._c.value.toFixed(decimals)
         }
 

package/src/maths/geometry/point.ts

@@ -53,6 +53,15 @@ export class Point {
         return `\\left(${pts.join(';')}\\right)`
     }
 
+    get display(): string {
+        let pts = [];
+
+        pts.push(this._x.tex);
+        pts.push(this._y.tex);
+
+        return `(${pts.join(';')})`
+    }
+
     // ------------------------------------------
     // Creation / parsing functions
     // ------------------------------------------

package/src/maths/geometry/vector.ts

@@ -18,10 +18,6 @@ export class Vector {
         }
     };
 
-    get isVector() {
-        return true;
-    }
-
     // ------------------------------------------
     // Getter and setter
     // ------------------------------------------
@@ -68,7 +64,7 @@ export class Vector {
         }
 
         if (values.length === 1) {
-            if (values[0].isVector) {
+            if (values[0] instanceof Vector) {
                 return values[0].clone()
             } else {
                 return this._parseString(values[0])

package/src/maths/random/index.ts

@@ -1,8 +1,10 @@
 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 {
@@ -14,6 +16,10 @@ export namespace Random {
         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)}
     export function numberSym(max:number, allowZero?:boolean):number { return rndHelpers.randomIntSym(max, allowZero)}
     export function bool(percent?:number):boolean { return rndHelpers.randomBool(percent)}

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,50 @@
 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');
+        expect(M0a.tex).to.be.equal('3')
+
+        const M0b = new Monom('x');
+        expect(M0b.tex).to.be.equal('x')
+
+        const M0c = new Monom('3x');
+        expect(M0c.tex).to.be.equal('3x')
+
+        const M1 = new Monom('3x^5');
+        expect(M1.tex).to.be.equal('3x^{5}')
+
+        const M2 = new Monom('2/3x^2yz^3y^4')
+        expect(M2.display).to.be.equal('2/3x^2y^5z^3')
+
+        const M3 = new Monom('-3x^(-2)')
+        expect(M3.tex).to.be.equal('-3x^{-2}')
+
+        const M4 = new Monom('3x^(2/3)')
+        expect(M4.tex).to.be.equal('3x^{2/3}')
+
+        const M5 = new Monom('-3x^(-2/3)y^(-5)8x^3')
+        expect(M5.tex).to.be.equal('-24x^{7/3}y^{-5}')
+    })
+
+    it('basic operations', ()=>{
+        const M1 = new Monom('3x'),
+            M2 = new Monom('2x')
+
+        expect(M1.clone().add(M2).isEqual(new Monom('5x'))).to.be.true
+        expect(M1.clone().subtract(M2).isEqual(new Monom('x'))).to.be.true
+        expect(M1.clone().multiply(M2).isEqual(new Monom('6x^2'))).to.be.true
+        expect(M1.clone().divide(M2).isEqual(new Monom('3/2'))).to.be.true
+    })
+
+    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 +52,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)
     });
 })