pimath 0.0.126 → 0.0.127

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pimath",
-  "version": "0.0.126",
+  "version": "0.0.127",
   "description": "A math library for teacher :)",
   "scripts": {
     "test": "mocha -r ts-node/register 'tests/**/*.test.ts'",

package/src/maths/algebra/polynom.ts

@@ -23,6 +23,13 @@ export interface IEuclidian {
  */
 export class Polynom {
     private _rawString: string;
+    private _dirty_factors: boolean
+    private _dirty_zeroes: boolean
+    private _euclidianCache: { [Key: string]: IEuclidian }
+    private _factors: Polynom[];
+    private _monoms: Monom[];
+    private _texString: string;
+    private _zeroes: ISolution[]
 
     /**
      *
@@ -40,8 +47,6 @@ export class Polynom {
         return this;
     }
 
-    private _dirty_factors: boolean
-
     // ------------------------------------------
     get dirty_factors(): boolean {
         return this._dirty_factors;
@@ -51,8 +56,6 @@ export class Polynom {
         this._dirty_factors = value;
     }
 
-    private _dirty_zeroes: boolean
-
     get dirty_zeroes(): boolean {
         return this._dirty_zeroes;
     }
@@ -61,8 +64,6 @@ export class Polynom {
         this._dirty_zeroes = value;
     }
 
-    private _euclidianCache: { [Key: string]: IEuclidian }
-
     get euclidianCache(): { [p: string]: IEuclidian } {
         return this._euclidianCache;
     }
@@ -71,8 +72,6 @@ export class Polynom {
         this._euclidianCache = value;
     }
 
-    private _factors: Polynom[];
-
     get factors(): Polynom[] {
         return this.factorize()
     }
@@ -82,8 +81,6 @@ export class Polynom {
         this._factors = value;
     }
 
-    private _monoms: Monom[];
-
     // ------------------------------------------
     get monoms() {
         return this._monoms;
@@ -93,14 +90,10 @@ export class Polynom {
         this._monoms = M;
     }
 
-    private _texString: string;
-
     get texString(): string {
         return this._texString;
     }
 
-    private _zeroes: ISolution[]
-
     get zeroes(): ISolution[] {
         return this.getZeroes()
     }
@@ -495,11 +488,11 @@ export class Polynom {
             // Get the greatest monom divided by the max monom of the divider
             newM = reminder.monomByDegree(undefined, letter).clone().divide(maxMP);
 
-            if (newM.isZero()) break;
+            if (newM.isZero()) continue;
 
             // Get the new quotient and reminder.
             quotient.add(newM);
-            reminder.subtract(P.clone().multiply(newM));
+            reminder.subtract(P.clone().multiply(newM)).reduce();
 
             // Check if the reminder is zero.
             if (newM.degree(letter).isZero()) break

package/src/maths/geometry/line.ts

@@ -9,7 +9,6 @@ import {Fraction} from "../coefficients/fraction";
 import {Equation} from "../algebra/equation";
 import {Polynom} from "../algebra/polynom";
 import {Random} from "../randomization/random";
-import {LinearSystem} from "../algebra/linearSystem";
 import {Monom} from "../algebra/monom";
 
 export enum LinePropriety {
@@ -26,7 +25,20 @@ export class Line {
     private _referencePropriety: LinePropriety
     private _referenceLine: Line
     private _reduceBeforeDisplay: boolean
+    // ax + by + c = 0
+    private _a: Fraction;
+    private _b: Fraction;
+    private _c: Fraction;
+    private _OA: Point;
+    private _d: Vector;
+    private _n: Vector;
+    private _exists: boolean
 
+    /**
+     * Value can be a mix of:
+     *
+     * @param values
+     */
     constructor(...values: unknown[]) {
 
         this._exists = false;
@@ -39,19 +51,17 @@ export class Line {
         return this;
     }
 
-    // ax + by + c = 0
-    private _a: Fraction;
-
     get a(): Fraction {
         return this._a;
     }
 
+    // ------------------------------------------
+    // Getter and setter
+
     set a(value: Fraction) {
         this._a = value;
     }
 
-    private _b: Fraction;
-
     get b(): Fraction {
         return this._b;
     }
@@ -60,21 +70,14 @@ export class Line {
         this._b = value;
     }
 
-    private _c: Fraction;
-
     get c(): Fraction {
         return this._c;
     }
 
-    // ------------------------------------------
-    // Getter and setter
-
     set c(value: Fraction) {
         this._c = value;
     }
 
-    private _OA: Point;
-
     get OA(): Point {
         return this._OA;
     }
@@ -83,8 +86,6 @@ export class Line {
         this._OA = value;
     }
 
-    private _d: Vector;
-
     get d(): Vector {
         return this._d;
     }
@@ -93,14 +94,10 @@ export class Line {
         this._d = value;
     }
 
-    private _n: Vector;
-
     get n(): Vector {
         return this._n;
     }
 
-    private _exists: boolean
-
     get exists(): boolean {
         return this._exists;
     }
@@ -108,19 +105,19 @@ export class Line {
     // ------------------------------------------
     get equation(): Equation {
         let equ = new Equation(new Polynom().parse('xy', this._a, this._b, this._c), new Polynom('0'))
-        if(this._reduceBeforeDisplay) {
+        if (this._reduceBeforeDisplay) {
             return equ.simplify();
-        }else{
+        } else {
             return equ
         }
     }
 
     get system(): { x: Equation, y: Equation } {
         let e1 = new Equation(
-            new Polynom('x'),
-            new Polynom(this._OA.x)
-                .add(new Monom('k').multiplyByNumber(this._d.x))
-        ),
+                new Polynom('x'),
+                new Polynom(this._OA.x)
+                    .add(new Monom('k').multiplyByNumber(this._d.x))
+            ),
             e2 = new Equation(
                 new Polynom('y'),
                 new Polynom(this._OA.y)

package/src/maths/geometry/point.ts

@@ -73,6 +73,20 @@ export class Point {
 
     // ------------------------------------------
     // Creation / parsing functions
+
+    get key(): string {
+        return `${this.x.display};${this.y.display}`
+    }
+
+    // ------------------------------------------
+    static pmatrix = (a: any, b: any, c?: any): string => {
+        if (c === undefined) {
+            return `\\begin{pmatrix} ${a.tex ? a.tex : a} \\\\ ${b.tex ? b.tex : b} \\end{pmatrix}`;
+        } else {
+            return `\\begin{pmatrix} ${a.tex ? a.tex : a} \\\\ ${b.tex ? b.tex : b} \\\\ ${c.tex ? c.tex : c} \\end{pmatrix}`;
+        }
+    };
+
     // ------------------------------------------
     parse = (...values: unknown[]): Point => {
         // Initialize the value.
@@ -103,9 +117,9 @@ export class Point {
             }
 
             // Value given as an object with {x: value, y: value}
-            if(values[0] instanceof PointXY){
-                    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()
@@ -138,6 +152,8 @@ export class Point {
         this.zero();
         return this;
     }
+    // ------------------------------------------
+    // Display functions
 
     middleOf = (P1: Point, P2: Point): Point => {
         this._x = P1.x.clone().add(P2.x).divide(2);
@@ -146,17 +162,6 @@ export class Point {
         return this;
     }
     // ------------------------------------------
-    // Display functions
-    // ------------------------------------------
-    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));
-
-        return `\\left(${pts.join(';')}\\right)`
-    }
-    // ------------------------------------------
     // Mathematical operations
     // ------------------------------------------
 
@@ -166,36 +171,45 @@ export class Point {
 
     // ------------------------------------------
     // Static functions
+
+    translate = (value: { x: number | Fraction, y: number | Fraction }): Point => {
+        this._x = this._x.add(value.x)
+        this._y = this._y.add(value.y)
+        return this
+    }
+
     // ------------------------------------------
-    static pmatrix = (a: any, b: any, c?: any): string => {
-        if (c === undefined) {
-            return `\\begin{pmatrix} ${a.tex ? a.tex : a} \\\\ ${b.tex ? b.tex : b} \\end{pmatrix}`;
-        } else {
-            return `\\begin{pmatrix} ${a.tex ? a.tex : a} \\\\ ${b.tex ? b.tex : b} \\\\ ${c.tex ? c.tex : c} \\end{pmatrix}`;
-        }
-    };
+    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));
+
+        return `\\left(${pts.join(';')}\\right)`
+    }
 
-    distanceTo = (item:Point|Line): { value: number, fraction: Fraction, tex: string } => {
+    distanceTo = (item: Point | Line): { value: number, fraction: Fraction, tex: string } => {
         let value = 0, fraction = new Fraction(), tex = ''
 
-        if(item instanceof Line){
+        if (item instanceof Line) {
             return item.distanceTo(this)
-        }else if(item instanceof Point){
+        } else if (item instanceof Point) {
             let V = new Vector(this, item)
 
             value = V.norm
             fraction = V.normSquare.sqrt()
             tex = V.normSquare.isSquare() ? fraction.tex : `\\sqrt{\\frac{ ${V.normSquare.numerator} }{ ${V.normSquare.denominator} }}`
         }
-        return { value, fraction, tex }
+        return {value, fraction, tex}
     }
 
-    get key(): string {
-      return `${this.x.display};${this.y.display}`
-}
     isInListOfPoints = (list: Point[]): boolean => {
-        const keyList = list.map(x=>x.key)
+        const keyList = list.map(x => x.key)
 
         return keyList.includes(this.key)
     }
+
+    isEqual = (pt: Point): boolean => {
+        return this.x.isEqual(pt.x) && this.y.isEqual(pt.y)
+    }
 }

package/src/maths/randomization/random.ts

@@ -3,6 +3,7 @@ import {rndMonom} from "./rndMonom";
 import {rndHelpers} from "./rndHelpers";
 import {
     randomCoefficientConfig,
+    randomGeometryCircleConfig,
     randomGeometryLineConfig,
     randomGeometryPointConfig,
     randomMonomConfig,
@@ -16,6 +17,8 @@ import {Line} from "../geometry/line";
 import {rndGeometryLine} from "./rndGeometryLine";
 import {Point} from "../geometry/point";
 import {rndGeometryPoint} from "./rndGeometryPoint";
+import {Circle} from "../geometry/circle";
+import {rndGeometryCircle} from "./rndGeometryCircle";
 
 export * from "./rndTypes"
 
@@ -69,5 +72,9 @@ export namespace Random {
             return (new rndGeometryPoint(config).generate())
         }
 
+        export function circle(config?: randomGeometryCircleConfig): Circle {
+            return (new rndGeometryCircle(config).generate())
+        }
+
     }
 }

package/src/maths/randomization/rndGeometryCircle.ts

@@ -0,0 +1,50 @@
+import {randomCore} from "./randomCore";
+import {Random, randomGeometryCircleConfig} from "./random";
+import {Circle} from "../geometry/circle";
+
+/**
+ * Create a random monom based on a based configuration
+ */
+export class rndGeometryCircle extends randomCore {
+    declare protected _config: randomGeometryCircleConfig
+    declare protected _defaultConfig: randomGeometryCircleConfig
+
+    generate = (): Circle => {
+        const center = Random.Geometry.point(this._config.center)
+
+        let rv, r
+        if (this._config.pointsOnCircle === 8) {
+            rv = Random.number(1, 3),
+                r = rv ** 2 + (rv + 1) ** 2
+        } else {
+            r = Random.number(1, 20)
+        }
+
+        const c = new Circle(center, r, true)
+
+
+        // let pts = c.getPointsOnCircle(true)
+        //
+        // pts = Random.shuffle(pts)
+        // let ptt = pts.shift(),
+        //     pt1 = pts.shift(),
+        //     pt2
+        //
+        // for (let pt of pts) {
+        //     if (!pt1.x.isEqual(pt.x) && !pt1.y.isEqual(pt.y) && !A.isEqual(new Point().middleOf(pt1, pt))) {
+        //         pt2 = pt.clone()
+        //         break
+        //     }
+        // }
+
+        return c
+
+    }
+
+    constructor(userConfig?: randomGeometryCircleConfig) {
+        super();
+
+        this._defaultConfig = {}
+        this._config = this.mergeConfig(userConfig, this._defaultConfig)
+    }
+}

package/src/maths/randomization/rndTypes.ts

@@ -4,14 +4,14 @@ export type randomCoefficientConfig = {
     negative?: boolean,
     max?: number,
     reduced?: boolean,
-    zero?:boolean,
-    natural?:boolean
+    zero?: boolean,
+    natural?: boolean
 }
 
 export type randomMonomConfig = {
     letters?: string,
     degree?: number,
-    fraction?: boolean|randomCoefficientConfig,
+    fraction?: boolean | randomCoefficientConfig,
     zero?: boolean
 }
 
@@ -29,9 +29,15 @@ export type randomGeometryLineConfig = {
 }
 
 
-export type randomGeometryPointConfig  = {
+export type randomGeometryPointConfig = {
     quadrant?: number,
     axis?: string | boolean,
     fraction?: boolean,
     max?: number
+}
+
+export type randomGeometryCircleConfig = {
+    center?: randomGeometryPointConfig,
+    radius?: number,
+    pointsOnCircle?: number
 }

package/tests/algebra/polynom.test.ts

@@ -67,6 +67,16 @@ describe('Polynom tests', () => {
         expect(euclidian.reminder.tex).to.be.equal('12')
     });
 
+    it('should calculate the quotient and reminder with similar polynom', () => {
+        let P = new Polynom('6x^5+12x^4+3x^3+x^2-7x+6'),
+            D = new Polynom('x^3+2x^2-2x-4')
+
+        let euclidian = P.euclidian(D);
+
+        expect(euclidian.quotient.display).to.be.equal('6x^(2)+15')
+        expect(euclidian.reminder.display).to.be.equal('-5x^(2)+23x+66')
+    })
+
     it('should reduce', () => {
         let P = new Polynom('15x-19x+24+4x-12')
         P.reduce()

package/tests/geometry/circle.test.ts

@@ -4,6 +4,8 @@ import {Circle} from "../../src/maths/geometry/circle";
 import {Line} from "../../src/maths/geometry/line";
 import {Point} from "../../src/maths/geometry/point";
 import {Fraction} from "../../src/maths/coefficients/fraction";
+import {Random} from "../../src/maths/randomization/random";
+import {Vector} from "../../src/maths/geometry/vector";
 
 describe('Circle', function () {
     it('should calculate the intersection of a circle and a line', function () {
@@ -67,7 +69,226 @@ describe('Circle', function () {
         // console.log(circle.tex)
     })
 
-    
+    it('tangentes pt ext', () => {
+        function makeCircle(): { circle: Circle, point: Point, tangents: Line[] } {
+            let A = Random.Geometry.point({axis: false}),
+                rv = Random.number(1, 3),
+                r = rv ** 2 + (rv + 1) ** 2
+            let c = new Circle(A, r, true)
+            let pts = c.getPointsOnCircle(true)
+
+            pts = Random.shuffle(pts)
+            let pt1: Point, pt2: Point, t1: Line, t2: Line, I: Point, n: Vector
+
+            pt1 = pts.shift()
+            for (let pt of pts) {
+                // Pas vertical / horizontal
+                n = new Vector(A, pt)
+
+                if (!n.x.isZero() && !n.y.isZero() &&   // pas vertical / horizontal
+                    !pt1.x.isEqual(pt.x) && !pt1.y.isEqual(pt.y) &&  // pas le même point
+                    !A.isEqual(new Point().middleOf(pt1, pt)) // pas l'un en face de l'autre
+                ) {
+                    pt2 = pt.clone()
+
+                    t1 = c.tangents(pt1)[0]
+                    t2 = c.tangents(pt2)[0]
+                    const intersection = t1.intersection(t2)
+
+                    if (intersection.hasIntersection && intersection.point.x.isRelative()) {
+                        I = intersection.point
+                        break
+                    }
+                }
+            }
+
+
+            return {
+                circle: c,
+                tangents: [t1, t2],
+                point: I
+            }
+        }
+
+        for (let i = 0; i < 30; i++) {
+            let {circle, tangents, point} = makeCircle()
+            console.log(`\\textbf{(exercice ${i + 1})}
+        
+        Calculer l'équation cartésiennes des tangentes au cercle \\( (\\Gamma): ${circle.tex} \\) passant par le point \\(P=${point.tex} \\)
+            \\iftoggle{master}{
+            (I) \\( ${tangents[0].tex.canonical} \\quad ${tangents[1].tex.canonical} \\)
+            }{}
+            \\vfill
+            ${i % 2 === 1 ? '\\newpage' : ''}
+            `)
+
+        }
+        /**
+         const C = new PiMath.Geometry.Circle(circle.value),
+         pts = C.getPointsOnCircle()
+
+         code.value = `C(${C.center.x.value},${C.center.y.value})
+         c=circ C,${C.radius.value}`
+
+         let tangents = []
+         pts.forEach((pt, index) => {
+         let tg = C.tangents(pt)[0]
+         tangents.push(tg)
+         code.value += `\nT${index + 1}(${pt.x.value},${pt.y.value})->tex:T_${index + 1}=@`
+         code.value += `\nt${index + 1}=line ${tg.tex.canonical}`
+
+         tangentPerPoints.value.push(`T_${index+1}(${pt.x.tex};${pt.y.tex})\\implies ${tg.tex.canonical}`)
+         })
+
+         for (let i = 0; i < tangents.length; i++) {
+         for (let j = i + 1; j < tangents.length; j++) {
+         let intersection = tangents[i].intersection(tangents[j])
+
+         if (intersection.hasIntersection) {
+         if (!intersection.point.isInListOfPoints(pts)) {
+         intersection.point.name=`I_{${i + 1}-${j + 1}}`
+         intersectionPoints.value.push({
+         point: `I_{${i+1}-${j+1}}${intersection.point.tex}`,
+         tangent1: tangents[i].tex.canonical,
+         tangent2: tangents[j].tex.canonical
+         })
+         code.value += `\nI_${i + 1}_${j + 1}(${intersection.point.x.value},${intersection.point.y.value})->tex:I_{${i+1}-${i+2}}=@`
+         }
+         }
+         }
+         }
+         */
+    })
+    it('tangentes temp tests', () => {
+        function makeCircle(): { circle: Circle, point: Point, tangent: Line, symetric: Line } {
+            let A = Random.Geometry.point({axis: false}),
+                rv = Random.number(1, 3),
+                r = rv ** 2 + (rv + 1) ** 2
+            let c = new Circle(A, r, true)
+            let pts = c.getPointsOnCircle(true)
+
+            pts = Random.shuffle(pts)
+            let pt: Point, n: Vector
+            for (let p of pts) {
+                n = new Vector(A, p)
+                if (!n.x.isZero() && !n.y.isZero()) {
+                    pt = p
+                    break
+                }
+            }
+
+            const p2 = new Point(A.x.clone(), A.y.clone()).translate({x: n.x.opposed(), y: n.y.opposed()})
+            const t = new Line(n, pt)
+            const s = new Line(n, p2)
+            return {
+                circle: c,
+                point: pt,
+                tangent: t,
+                symetric: s
+            }
+        }
+
+        for (let i = 0; i < 30; i++) {
+
+            const data1 = makeCircle()
+            const item1 = `Calculer l'équation de la tangente au cercle d'équation \\( (\\Gamma_1): ${data1.circle.tex} \\) un cercle passant par le point \\( T=${data1.point.tex} \\).`
+
+            const data2 = makeCircle()
+            const item2 = `Calculer l'équation des tangentes au cercle d'équation \\( (\\Gamma_2): ${data2.circle.cartesian.tex} \\) de pente \\( \\displaystyle ${data2.tangent.slope.tex} \\).`
+
+            console.log(`\\textbf{(exercice ${i + 1})}
+        
+        \\begin{enumerate}[(I),itemsep=10em] 
+        \\item ${item1}
+        \\item ${item2}
+            \\end{enumerate}
+            \\iftoggle{master}{
+            (I) \\( ${data1.tangent.tex.canonical} \\)
+            
+            (II) \\( (\\Gamma_2): ${data2.circle.tex} \\) \\\\ \\( (t_1): ${data2.tangent.tex.canonical} \\) et \\( (t_2): ${data2.symetric.tex.canonical} \\)
+            
+            }{}
+            \\vfill
+            ${i % 2 === 1 ? '\\newpage' : ''}
+            `)
+
+        }
+    })
+//     it('intersection temp tests', () => {
+//         for (let i = 0; i < 30; i++) {
+//             let A = Random.Geometry.point({axis: false}),
+//                 rv = Random.number(1, 3),
+//                 r = rv ** 2 + (rv + 1) ** 2
+//
+//             let c = new Circle(A, r, true)
+//             let pts = c.getPointsOnCircle(true)
+//             // console.log(r, pts.length)
+//
+//             // console.log(c.tex)
+//             // console.log(pts.map(pt => pt.display))
+//             pts = Random.shuffle(pts)
+//             let ptt = pts.shift(),
+//                 pt1 = pts.shift(),
+//                 pt2
+//
+//             for (let pt of pts) {
+//                 if (!pt1.x.isEqual(pt.x) && !pt1.y.isEqual(pt.y) && !A.isEqual(new Point().middleOf(pt1, pt))) {
+//                     pt2 = pt.clone()
+//                     break
+//                 }
+//             }
+//
+//             // console.log('Pt de tangence')
+//             // console.log(ptt.display)
+//             let t = c.tangents(ptt)[0]
+//             // console.log(t.tex.canonical)
+//
+//             // console.log('intersection en deux points')
+//             // console.log(pt1.display, pt2.display)
+//             let d = new Line(pt1, pt2)
+//             // console.log(d.tex.canonical)
+//
+//             let P = Random.Geometry.point()
+//             while (P.x.isEqual(c.center.x) || P.y.isEqual(c.center.y)) {
+//                 P = Random.Geometry.point()
+//             }
+//             // Le point P n'est pas sur le centre.
+//             let v = new Vector(c.center, P)
+//             while (P.distanceTo(A).value <= Math.sqrt(r)) {
+//                 P.x.add(v.x)
+//                 P.y.add(v.y)
+//             }
+//             let p = new Line(P, v, LinePropriety.Perpendicular)
+//             // console.log(P.display)
+//             // console.log(p.display.canonical)
+//
+//             let lignes = Random.shuffle([t, d, p])
+//
+// //             console.log(`A${A.display}
+// // c=circ A,${Math.sqrt(r)}
+// // T${ptt.display}
+// // P${pt1.display}
+// // Q${pt2.display}
+// // t=line ${t.display.canonical}
+// // d=line ${d.display.canonical}
+// // p=line ${p.display.canonical}`)
+//             console.log(`(exercice ${i + 1}): Soit \\(\\Gamma\\) un cercle et \\(d_1\\), \\(d_2\\) et \\(d_3\\) trois droites.
+//             \\mathleft
+//             \\[(\\Gamma): ${c.tex}\\]
+//             \\[(d_1): ${lignes[0].tex.canonical} \\qquad (d_2): ${lignes[1].tex.canonical}  \\qquad (d_3): ${lignes[2].tex.canonical}\\]
+//
+//             \\begin{enumerate}[label=\\Alph*]
+//             \\item déterminer les positions relatives de \\(d_1\\), \\(d_2\\) et \\(d_3\\) par rapport à \\(\\Gamma\\)
+//             \\item calculer les coordonnées du ou des points d'intersection entre le cercle et une des droites qui le coupe (au choix).
+//             \\end{enumerate}
+//             \\iftoggle{master}{\\(${t.tex.canonical}\\implies ${ptt.tex}\\) \\\\ \\(${d.tex.canonical}\\implies ${pt1.tex},\\ ${pt2.tex}\\) \\\\}{}
+//             \\vfill
+//             ${i % 2 === 1 ? '\\newpage' : ''}
+//             `)
+//
+//         }
+//
+//     })
 //     it('temp tests', () => {
 //         for (let i = 0; i < 30; i++) {
 //             let A = Random.Geometry.point({axis: false}),

package/tests/numeric.test.ts

@@ -8,7 +8,7 @@ describe('Numeric', () => { // the tests container
         expect(Numeric.numberCorrection(a)).to.be.equal(0.3)
         const b = Math.pow(10, -5)
 
-        expect(Numeric.numberCorrection(b, 1,12)).to.be.equal(0.00001)
+        expect(Numeric.numberCorrection(b, 1, 12)).to.be.equal(0.00001)
     })
 
 
@@ -21,7 +21,23 @@ describe('Numeric', () => { // the tests container
     })
 
     it('should decompose a number in two factors', function () {
-        expect(Numeric.decompose(25).map(x=>x.join(','))).to.have.all.members(['1,25', '5,5'])
-        expect(Numeric.decompose(6).map(x=>x.join(','))).to.have.all.members(['1,6', '2,3'])
+        expect(Numeric.decompose(25).map(x => x.join(','))).to.have.all.members(['1,25', '5,5'])
+        expect(Numeric.decompose(6).map(x => x.join(','))).to.have.all.members(['1,6', '2,3'])
     });
+
+    it('algo perso', () => {
+        for (let n = 1000; n < 10000; n++) {
+            const a = Math.trunc(n / 1000)
+            const b = Math.trunc((n - 1000 * a) / 100)
+            const c = Math.trunc((n - 1000 * a - 100 * b) / 10)
+            const d = Math.trunc(n - 1000 * a - 100 * b - 10 * c)
+
+            const p = a + b + c + d
+            const p2 = a ** 2 + b ** 2 + c ** 2 + d ** 2
+
+            if (n === p * p2 ** 2) {
+                console.log(n)
+            }
+        }
+    })
 });