pimath 0.0.21 → 0.0.25

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/random/index.ts

@@ -7,6 +7,7 @@ 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()
@@ -20,10 +21,27 @@ export namespace Random {
         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)}
-    export function array(arr:any[], number?:number):any[] { return rndHelpers.randomArray(arr, number)}
-    export function item(arr:any[]):any { return rndHelpers.randomItem(arr)}
-    export function shuffle(arr:any[]):any { rndHelpers.shuffleArray(arr)}
+    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)
+    }
+
+    export function array(arr: any[], number?: number): any[] {
+        return rndHelpers.randomArray(arr, number)
+    }
+
+    export function item(arr: any[]): any {
+        return rndHelpers.randomItem(arr)
+    }
+
+    export function shuffle(arr: any[]): any {
+        rndHelpers.shuffleArray(arr)
+    }
 }

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
 }

package/tests/algebra/monom.test.ts

@@ -1,10 +1,11 @@
 import {expect} from 'chai';
 import {Monom} from "../../src/maths/algebra";
 import {Random} from "../../src/maths/random";
-import exp = require("constants");
+import {describe} from "mocha";
+import {Fraction} from "../../src/maths/coefficients";
 
-describe('Monom tests', ()=> {
-    it('parsing', ()=>{
+describe('Monom tests', () => {
+    it('parsing', () => {
         const M0a = new Monom('3');
         expect(M0a.tex).to.be.equal('3')
 
@@ -30,7 +31,7 @@ describe('Monom tests', ()=> {
         expect(M5.tex).to.be.equal('-24x^{7/3}y^{-5}')
     })
 
-    it('basic operations', ()=>{
+    it('basic operations', () => {
         const M1 = new Monom('3x'),
             M2 = new Monom('2x')
 
@@ -64,3 +65,16 @@ describe('Monom tests', ()=> {
         expect(M.degree().value).to.be.greaterThan(0)
     });
 })
+
+describe('Monom as numerical expression', () => {
+    it('should create a numerical expression', () => {
+        let M = new Monom()
+
+        M.coefficient = new Fraction(3, 7)
+        M.setLetter('3', new Fraction(0.5).reduce())
+
+        console.log(M.tex)
+        // TODO: Problem while displaying numerical expression
+        console.log(M.display)
+    })
+})

package/tests/algebra/polynom.test.ts

@@ -1,7 +1,8 @@
 import {expect} from 'chai';
 import {Fraction} from "../../src/maths/coefficients";
-import {Polynom} from "../../src/maths/algebra";
+import {Monom, Polynom} from "../../src/maths/algebra";
 import {Random} from "../../src/maths/random";
+import {describe} from "mocha";
 
 describe('Polynom tests', () => {
     it('Parse polynom', () => {
@@ -38,10 +39,15 @@ describe('Polynom tests', () => {
     it('Random Polynom of degree 5', function () {
         let P = Random.polynom({
             degree: 6,
-            numberOfMonoms: 3
+            numberOfMonoms: 3,
+            positive: true,
+            fraction: {
+                max: 3
+            }
         })
 
+        console.log(P.tex)
         expect(P.length).to.be.equal(3)
-        expect(P.degree().value).to.be.lessThanOrEqual(6)
+        expect(P.degree().value).to.be.equal(6)
     });
-})
+})

package/tests/geometry/circle.test.ts

@@ -0,0 +1,28 @@
+import {describe} from "mocha";
+import {Circle, Line, Point} from "../../src/maths/geometry";
+import {Fraction} from "../../src/maths/coefficients";
+import {expect} from "chai";
+
+describe('Circle', function () {
+    it('should calculate the intersection of a circle and a line', function () {
+        let C = new Circle(
+            new Point(8, 6),
+            20,
+            true
+        ),
+            LT = new Line('2x+y-32=0'),
+            LS = new Line('3x-y-8=0'),
+            IPT = C.lineIntersection(LT),
+            IPS = C.lineIntersection(LS)
+
+        expect(IPT).to.be.length(1)
+        expect(IPT[0].x.value).to.be.equal(12)
+        expect(IPT[0].y.value).to.be.equal(8)
+
+        expect(IPS).to.be.length(2)
+        expect(IPS[0].x.value).to.be.equal(4)
+        expect(IPS[0].y.value).to.be.equal(4)
+        expect(IPS[1].x.value).to.be.equal(6)
+        expect(IPS[1].y.value).to.be.equal(10)
+    });
+});

package/tsconfig.json

@@ -8,6 +8,9 @@
       "src/maths/numeric.ts",
       "src/maths/shutingyard.ts"
     ],
+    "plugin": [
+      "./typedoc.katex.js"
+    ],
     "out": "docs"
   },
   "compilerOptions": {
@@ -16,7 +19,7 @@
     "module": "commonjs",
     "target": "esnext",
     "allowJs": true,
-//    "jsx": "react",
+    //    "jsx": "react-jsx",
     "sourceMap": true,
     "moduleResolution": "node",
     "declaration": true,

package/typedoc.katex.js

@@ -0,0 +1,11 @@
+const { JSX } = require("typedoc");
+
+exports.load = function (app) {
+    app.renderer.hooks.on("head.end", () => {
+        return JSX.createElement(JSX.Fragment, null,
+            JSX.createElement("link", { rel: "stylesheet", href: "https://cdn.jsdelivr.net/npm/katex@0.15.1/dist/katex.min.css", integrity: "sha384-R4558gYOUz8mP9YWpZJjofhk+zx0AS11p36HnD2ZKj/6JR5z27gSSULCNHIRReVs", crossorigin: "anonymous" },
+                JSX.createElement("script", { defer: true, src: "https://cdn.jsdelivr.net/npm/katex@0.15.1/dist/katex.min.js", integrity: "sha384-z1fJDqw8ZApjGO3/unPWUPsIymfsJmyrDVWC8Tv/a1HeOtGmkwNd/7xUS0Xcnvsx", crossorigin: "anonymous" }),
+                JSX.createElement("script", { defer: true, src: "https://cdn.jsdelivr.net/npm/katex@0.15.1/dist/contrib/auto-render.min.js", integrity: "sha384-+XBljXPPiv+OzfbB3cVmLHf4hdUFHlWNZN5spNQ7rmHTXpd7WvJum6fIACpNNfIR", crossorigin: "anonymous", onload: "renderMathInElement(document.body);" })),
+            "}); }");
+    });
+}