pimath 0.0.124 → 0.0.126

package/src/maths/randomization/rndHelpers.ts

@@ -9,8 +9,8 @@ export class rndHelpers {
      * Random boolean with a percent ratio
      * @param percent
      */
-    static randomBool(percent:number=0.5):boolean{
-        return Math.random()<percent;
+    static randomBool(percent: number = 0.5): boolean {
+        return Math.random() < percent;
     }
 
     /**
@@ -18,10 +18,35 @@ export class rndHelpers {
      * @param a (number) : From this value to the second value. If the second is ommited, this value is the max value.
      * @param b (number) : To this value. If this is ommited.
      */
-    static randomInt(a:number, b?:number):number{
-        if(b===undefined){return this.randomInt(0,a);}
+    static randomInt(a: number, b?: number, exclude?: number[]): number {
+        if (b === undefined) {
+            if (a >= 0) {
+                return this.randomInt(0, a);
+            } else {
+                return this.randomInt(a, 0);
+            }
+        }
+
+        // Same start and end values
+        if (a === b) {
+            return a
+        }
 
-        return Math.floor(Math.random() * (b - a + 1) + a);
+        // No exclusion
+        if (exclude === undefined) {
+            return Math.floor(Math.random() * (b - a + 1) + a);
+        }
+
+        // With exclusion
+        if (Math.abs(b - a) <= exclude.length) {
+            throw new Error('The number of excluded values is too high.')
+        }
+
+        let r = this.randomInt(a, b)
+        while (exclude.includes(r)) {
+            r = this.randomInt(a, b)
+        }
+        return r
     }
 
     /**
@@ -29,35 +54,41 @@ export class rndHelpers {
      * @param max (number) : determine the limits.
      * @param zero (bool) : determine if zero is allowed or not.
      */
-    static randomIntSym(max:number, zero?:boolean):number{
-        if(zero===false){
-            return this.randomBool()?this.randomInt(1,max):-this.randomInt(1,max);
-        }else{
+    static randomIntSym(max: number, zero?: boolean): number {
+        if (zero === false) {
+            return this.randomBool() ? this.randomInt(1, max) : -this.randomInt(1, max);
+        } else {
             return this.randomInt(-max, max);
         }
     }
 
     static randomPrime(max: number): number {
         let primes = Numeric.primes()
-        if(max!==undefined){
-            primes = primes.filter(x=>x<max)
+        if (max !== undefined) {
+            primes = primes.filter(x => x < max)
         }
         return this.randomItem(primes)
     }
 
-    static randomArray(arr: any[], number?:number):any[]{
-        if(number===undefined){number = 1}
+    static randomArray(arr: any[], number?: number): any[] {
+        if (number === undefined) {
+            number = 1
+        }
 
         // Return a clone array
-        if(arr.length<=0){return Object.values(arr)}
+        if (arr.length <= 0) {
+            return Object.values(arr)
+        }
 
         // Randomize the array and return the n first elements.
-        return rndHelpers.shuffleArray(arr).slice(0,number);
+        return rndHelpers.shuffleArray(arr).slice(0, number);
     }
 
-    static randomItem(arr: any[]): any{
-        if(arr.length===0){return ''}
-        return this.randomArray(arr, 1)[0]
+    static randomItem(arr: any[]): any {
+        if (arr.length === 0) {
+            return ''
+        }
+        return arr[this.randomInt(0, arr.length - 1)]
     }
 
     static shuffleArray(arr: any[]): any[] {

package/tests/algebra/linear.test.ts

@@ -40,7 +40,7 @@ describe('Linear systems tests', () => {
             E2 = new Polynom('-6x+21y-3z')
 
         E1.add(E2);
-        expect(E1.display).to.be.equal('42y-6z')
+        expect(E1.reduce().display).to.be.equal('42y-6z')
     });
 
     it('should use a reduced linear reducation', function () {

package/tests/algebra/polynom.test.ts

@@ -67,6 +67,13 @@ describe('Polynom tests', () => {
         expect(euclidian.reminder.tex).to.be.equal('12')
     });
 
+    it('should reduce', () => {
+        let P = new Polynom('15x-19x+24+4x-12')
+        P.reduce()
+        expect(P.tex).to.be.equal('12')
+
+    })
+
     it('should factorize the polynom', () => {
         let P = new Polynom('x^2-5x+6')
 
@@ -99,7 +106,7 @@ describe('Polynom tests', () => {
         expect(P2.texFactors).to.be.equal('-2x\\left( x+3 \\right)\\left( x-3 \\right)')
     });
 
-    it('should detect if a polynom is factorized', function (){
+    it('should detect if a polynom is factorized', function () {
         let P = new Polynom('x-1')
         expect(P.isFactorized('x-1')).to.be.true
         expect(P.isFactorized('x-2')).to.be.false
@@ -164,6 +171,12 @@ describe('Polynom parsing with rational power', () => {
     })
 })
 
+describe("Polynom with multiple variables", () => {
+    it('should parse with multiple variables', () => {
+        const P = new Polynom('ax')
+        expect(P.display).to.be.equal('ax')
+    })
+})
 
 // describe("test simple", ()=>{
 //     it('should parce this one correctly', ()=>{
@@ -180,3 +193,141 @@ describe('Polynom parsing with rational power', () => {
 //         expect(P.degree().value).to.be.equal(0.5)
 //     })
 // })
+//
+// describe('Polynom used as complex number', () => {
+//     let P = new Polynom('4+3i')
+//
+//     P.pow(2)
+//
+//     P.monoms.forEach(m => {
+//         const d = m.degree('i').value
+//         if (d >= 2) {
+//             if (d % 2 === 0) {
+//                 m.coefficient = m.coefficient.multiply((-1) ** (d / 2))
+//                 m.setLetter('i', 0)
+//             } else {
+//                 m.coefficient = m.coefficient.multiply((-1) ** ((d - 1) / 2))
+//                 m.setLetter('i', 1)
+//             }
+//         }
+//     })
+//     // console.log(P.reduce().tex)
+//
+// })
+//
+// describe("making my test", () => {
+//     let models = [
+//         {
+//             question: 'B \\cdot A^{K}=C',
+//             answer: {
+//                 log: (a: number, b: number, c: number, d: number, e: number) => new Fraction(c, b),
+//                 poly: (k: Polynom, p: Polynom) => k.clone()
+//             }
+//         },
+//         {
+//             question: 'B \\cdot A^{K}=C',
+//             answer: {
+//                 log: (a: number, b: number, c: number, d: number, e: number) => new Fraction(c, b),
+//                 poly: (k: Polynom, p: Polynom) => k.clone()
+//             }
+//         },
+//         {
+//             question: 'A^{K}=B \\cdot A^{P}',
+//             answer: {
+//                 log: (a: number, b: number, c: number, d: number, e: number) => new Fraction(b),
+//                 poly: (k: Polynom, p: Polynom) => k.clone().subtract(p)
+//             }
+//         },
+//         {
+//             question: 'A^{K}=B \\cdot A^{P}',
+//             answer: {
+//                 log: (a: number, b: number, c: number, d: number, e: number) => new Fraction(b),
+//                 poly: (k: Polynom, p: Polynom) => k.clone().subtract(p)
+//             }
+//         },
+//         {
+//             question: 'B \\cdot A^{K} = C \\cdot A^{P}',
+//             answer: {
+//                 log: (a: number, b: number, c: number, d: number, e: number) => new Fraction(c, b),
+//                 poly: (k: Polynom, p: Polynom) => k.clone().subtract(p)
+//             }
+//         },
+//         {
+//             question: 'B \\cdot A^{K} = \\frac{ C }{ A^{P} }',
+//             answer: {
+//                 log: (a: number, b: number, c: number, d: number, e: number) => new Fraction(c, b),
+//                 poly: (k: Polynom, p: Polynom) => k.clone().add(p)
+//             }
+//         },
+//         {
+//             question: 'C \\cdot A^{K} - B = D',
+//             answer: {
+//                 log: (a: number, b: number, c: number, d: number, e: number) => new Fraction(d + b, c),
+//                 poly: (k: Polynom, p: Polynom) => k.clone()
+//             }
+//         },
+//         {
+//             question: 'C \\cdot A^{K} - B = D \\cdot A^{P} ',
+//             answer: {
+//                 log: (a: number, b: number, c: number, d: number, e: number) => new Fraction(b, c - e),
+//                 poly: (k: Polynom, p: Polynom) => k.clone()
+//             }
+//         },
+//     ]
+//
+//
+//     for (let i = 0; i < 15; i++) {
+//         console.log(`{\\centering \\huge équations logarithmiques \\\\ }\n\nRésoudre les équations suivantes. Donner la réponse sous forme exacte et avec 4 décimales.`)
+//
+//         console.log(`\\begin{enumerate}[(i),itemsep=4em]\n`)
+//
+//         for (let m of models) {
+//             let a = PiMath.Random.number(2, 9),
+//                 b = PiMath.Random.number(2, 9),
+//                 c = PiMath.Random.number(2, 9),
+//                 d = PiMath.Random.number(1, 9),
+//                 e = PiMath.Random.number(1, c - 1),
+//                 k = PiMath.Random.polynom({degree: 1}),
+//                 p = PiMath.Random.polynom({degree: 1})
+//
+//             if (k.monomByDegree(1).coefficient.isNegative()) {
+//                 k.opposed()
+//             }
+//             if (p.monomByDegree(1).coefficient.isNegative()) {
+//                 p.opposed()
+//             }
+//
+//             let poly = m.answer.poly(k, p),
+//                 pa = poly.monomByDegree(1).coefficient,
+//                 pb = poly.monomByDegree(0).coefficient
+//
+//             if (pa.isZero()) {
+//                 k = k.add('x')
+//                 poly = m.answer.poly(k, p),
+//                     pa = poly.monomByDegree(1).coefficient,
+//                     pb = poly.monomByDegree(0).coefficient
+//             }
+//
+//             const question = m.question
+//                 .replaceAll('A', a.toString())
+//                 .replaceAll('B', b.toString())
+//                 .replaceAll('C', c.toString())
+//                 .replaceAll('D', d.toString())
+//                 .replaceAll('K', k.tex)
+//                 .replaceAll('P', p.tex)
+//
+//
+//             const log = m.answer.log(a, b, c, d, e).reduce()
+//             let answer = `\\log_{ ${a} }\\left( ${log.tex} \\right)`
+//             if (!pb.isZero()) answer = `${answer}${pb.clone().opposed().texWithSign}`
+//             if (!pa.isOne()) answer = `\\frac{ ${answer} }{ ${pa.tex} }`
+//
+//             let value = ((Math.log10(log.value) / Math.log10(a) - pb.value) / pa.value).toFixed(4)
+//
+//             console.log(`\\item \\(\\displaystyle ${question}\\) \\hfill \\( \\trou{ ${answer}=${value} } \\)`)
+//         }
+//
+//         console.log(`\\end{enumerate}\n\\newpage`)
+//     }
+//
+// })

package/tests/algebra/study.test.ts

@@ -5,6 +5,7 @@ import {expect} from "chai";
 import {ASYMPTOTE} from "../../src/maths/algebra/study";
 
 describe('Study tests', () => {
+
     it('should get the zeroes', function () {
         const study = new RationalStudy(
             // new Rational('x^2-4x-4', 'x+7')

package/tests/geometry/circle.test.ts

@@ -8,10 +8,10 @@ import {Fraction} from "../../src/maths/coefficients/fraction";
 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
-        ),
+                new Point(8, 6),
+                20,
+                true
+            ),
             LT = new Line('2x+y-32=0'),
             LS = new Line('3x-y-8=0'),
             IPT = C.lineIntersection(LT),
@@ -28,7 +28,7 @@ describe('Circle', function () {
         expect(IPS[1].y.value).to.be.equal(10)
     });
 
-    it('should calculate tangents', function(){
+    it('should calculate tangents', function () {
 
         // Through one point on the circle
         const C = new Circle(
@@ -37,18 +37,18 @@ describe('Circle', function () {
             true
         ), P = new Point(-5, 7);
 
-        expect(C.tangents(P).map(x=>x.tex.canonical)).to.have.all.members(['3x-4y+43=0'])
+        expect(C.tangents(P).map(x => x.tex.canonical)).to.have.all.members(['3x-4y+43=0'])
 
         // With a slope
         const D = new Circle('x^2+y^2+10x=2y-6'),
             slope = new Fraction(-2, 1)
 
-        expect(D.tangents(slope).map(x=>x.tex.canonical)).to.have.all.members(['2x+y-1=0', '2x+y+19=0'])
+        expect(D.tangents(slope).map(x => x.tex.canonical)).to.have.all.members(['2x+y-1=0', '2x+y+19=0'])
 
         const E = new Circle('(x-2)^2+(y-1)^2=5'),
             P2 = new Point(6, -2)
 
-        expect(E.tangents(P2).map(x=>x.tex.canonical)).to.have.all.members(['2x+y-10=0','2x+11y+10=0'])
+        expect(E.tangents(P2).map(x => x.tex.canonical)).to.have.all.members(['2x+y-10=0', '2x+11y+10=0'])
 
         let P3 = new Point(2, 2)
         expect(E.tangents(P3)).to.be.empty
@@ -58,27 +58,126 @@ describe('Circle', function () {
         const C = new Circle('(x-3)^2+(y+4)^2=16'),
             pts = C.getPointsOnCircle()
 
-        expect(pts.map(x=>x.x.display + ',' + x.y.display)).to.have.all.members([ '3,0', '3,-8', '7,-4', '-1,-4' ])
+        expect(pts.map(x => x.x.display + ',' + x.y.display)).to.have.all.members(['3,0', '3,-8', '7,-4', '-1,-4'])
     });
 
-    it('should calculate the circle from center and radius', function(){
+    it('should calculate the circle from center and radius', function () {
         let circle = new Circle("x^2+6x+y^2-8y+12=0")
 
-        console.log(circle.tex)
+        // console.log(circle.tex)
     })
 
-    it('should parse a line', function () {
-        let a1 = 133.33333333333331,
-            b1 = 700,
-            a2 = 134.33333333333331,
-            b2 = 700.75
-
-        let A = new Point(a1, a2),
-            B = new Point(b1, b2)
-
-        console.log(A.tex, B.tex)
-
-        let L = new Line(A, B)
-        console.log(L.tex.canonical)
-    });
+    
+//     it('temp tests', () => {
+//         for (let i = 0; i < 30; i++) {
+//             let A = Random.Geometry.point({axis: false}),
+//                 B = Random.Geometry.point({axis: false})
+//
+//             if (Random.bool()) {
+//                 B.x = new Fraction().zero()
+//             } else {
+//                 B.y = new Fraction().zero()
+//             }
+//
+//             const c1 = new Circle(A, Random.number(1, 10)),
+//                 c2 = new Circle(B, Random.number(1, 10))
+//
+//             console.log(`(exercice ${i + 1}): déterminer la forme \\textbf{centre-rayon} des équations cartésiennes suivantes. En déduire le centre et le rayon du cercle.
+//     \\begin{enumerate}[label=\\Alph*]
+//     \\item \\( (\\Gamma_1): ${c1.developed}\\) \\iftoggle{master}{\\(${c1.tex}\\)}{}
+//     \\item \\( (\\Gamma_2): ${c2.developed}\\) \\iftoggle{master}{\\(${c2.tex}\\)}{}
+//     \\end{enumerate}
+//     \\vfill
+//     ${i % 2 === 1 ? '\\newpage' : ''}
+//     `)
+//         }
+//     })
+//
+//     it('temp tests 2', () => {
+//         const q = `(I): Soit \\(\\Gamma_1\\) et \\(\\Gamma_2\\) deux cercles. Déterminer leur position relative à l'aide des informations ci-dessous.
+//
+// \\[(\\Gamma_1): @G1 \\qquad (\\Gamma_2): @G2 \\]
+// \\[\\trou{@R1} \\]
+//
+// \\vspace{3cm}
+// (II): Soit \\((\\Gamma_3):  @G3\\) un cercle. Déterminer l'équation cartésienne, sous sa forme centre-sommet, des cercles \\(\\Gamma_4\\) de rayon \\(@RAYON\\) qui sont tangents à \\(\\Gamma_3\\) en sachant que les deux centres ont la même @AXE.\\\\
+// Préciser la position relative entre \\(\\Gamma_3\\) et \\(\\Gamma_4\\)
+// \\[ \\trou{@R2a} \\]
+// \\[ \\trou{@R2b} \\]
+// `
+//
+//         for (let i = 0; i < 30; i++) {
+//             let A = Random.Geometry.point({axis: false}),
+//                 triplet = Random.item(Numeric.pythagoricianTripletsWithTarget(
+//                     Random.item([5, 13, 17, 25, 29, 37, 41])
+//                 ).filter(tr => {
+//                     // remove all items with zero values.
+//                     return tr.every(x => x !== 0)
+//                 })),
+//                 B = new Point(
+//                     A.x.value + triplet[0],
+//                     A.y.value + triplet[1]
+//                 ),
+//                 delta = Random.number(2, triplet[2] - 1),
+//                 positionRelative = ['extérieure', 'intérieure', 'sécante', 'disjointe'][i % 4],
+//                 // positionRelative = Random.item(['extérieure', 'intérieure', 'sécante', 'disjointe']),
+//                 c1: Circle, c2: Circle
+//
+//             if (positionRelative === 'extérieure') {
+//                 c1 = new Circle(A, triplet[2] - delta)
+//                 c2 = new Circle(B, delta)
+//             } else if (positionRelative === 'intérieure') {
+//                 c1 = new Circle(A, triplet[2] + delta)
+//                 c2 = new Circle(B, delta)
+//             } else if (positionRelative === 'sécante') {
+//                 c1 = new Circle(A, triplet[2] + delta - Random.number(1, delta - 1))
+//                 c2 = new Circle(B, delta)
+//             } else if (positionRelative === 'disjointe') {
+//                 c1 = new Circle(A, triplet[2] + delta + 1)
+//                 c2 = new Circle(B, delta)
+//             }
+//
+//             const R1 = `\\delta(O_1;O_2)=${A.distanceTo(B).value}\\qquad r_1=${c1.radius.value} \\qquad ${c2.radius.value} \\qquad \\implies \\text{${positionRelative}} `
+//
+//
+//             let C = Random.Geometry.point({axis: false}),
+//                 r1 = Random.number(2, 10),
+//                 c3 = new Circle(C, r1),
+//                 // Get a random number from 2 to 10 that is not equal to r1
+//                 r2 = Random.number(2, 10, [r1]),
+//                 axis = Random.item(['abscisse', 'ordonnée']),
+//                 centers: Point[] = []
+//
+//             const c3x = c3.center.x.value,
+//                 c3y = c3.center.y.value
+//             if (axis === 'abscisse') {
+//
+//                 centers = [
+//                     new Point(c3x, c3y - (r1 + r2)),
+//                     new Point(c3x, c3y - (r2 - r1)),
+//                     new Point(c3x, c3y - (r1 - r2)),
+//                     new Point(c3x, c3y + (r1 + r2))
+//                 ]
+//             } else {
+//                 centers = [
+//                     new Point(c3x - (r1 + r2), c3y),
+//                     new Point(c3x - (r2 - r1), c3y),
+//                     new Point(c3x - (r1 - r2), c3y),
+//                     new Point(c3x + (r1 + r2), c3y)
+//                 ]
+//             }
+//
+//             console.log(`(exercice ${i + 1}): ` + q
+//                     .replaceAll('@G1', c1.tex)
+//                     .replaceAll('@R1', R1)
+//                     .replaceAll('@G2', c2.tex)
+//                     .replaceAll('@G3', c3.developed)
+//                     .replaceAll('@RAYON', r2.toString())
+//                     .replaceAll('@AXE', axis)
+//                     .replaceAll('@R2a', centers.slice(0, 2).map(x => new Circle(x, r2).tex).join(' \\qquad '))
+//                     .replaceAll('@R2b', centers.slice(2, 4).map(x => new Circle(x, r2).tex).join(' \\qquad '))
+//                 + '\\vfill' + (i % 2 === 1 ? '\\newpage' : '')
+//             )
+//         }
+//     })
 });

package/tests/geometry/line.test.ts

@@ -2,44 +2,35 @@ import {describe} from "mocha";
 import {Line} from "../../src/maths/geometry/line";
 import {Point} from "../../src/maths/geometry/point";
 import {expect} from "chai";
-import {Equation} from "../../src/maths/algebra/equation";
-import {Polynom} from "../../src/maths/algebra/polynom";
-import {Monom} from "../../src/maths/algebra/monom";
 
 describe('Geometry Line', function () {
     it('should evaluate coordinates', function () {
         let L = new Line('3x-4y+5=0')
 
         let y = L.getValueAtX(0)
-        console.log(y.tex)
+        expect(y.display).to.be.equal('5/4')
     });
 
     it('should output nice Tex', function () {
         let L = new Line('9x-8y-96=0'),
             tex = L.tex
 
-        console.log(tex.canonical)
-        console.log(tex.equation)
-        console.log(tex.mxh)
-        console.log(tex.parametric)
-
-        console.log(tex.system)
+        expect(tex.canonical).to.be.equal('9x-8y-96=0')
+        expect(tex.equation).to.be.equal('9x-8y=96')
+        expect(tex.mxh).to.be.equal('y=\\frac{ 9 }{ 8 }x-12')
+        expect(tex.parametric).to.be.equal('\\begin{pmatrix} x \\\\ y \\end{pmatrix} = \\begin{pmatrix} 0 \\\\ -96 \\end{pmatrix} + k\\cdot \\begin{pmatrix} -8 \\\\ -9 \\end{pmatrix}')
+        // console.log(tex.system)
     });
 
     it('should parse line from canonical coefficient', function () {
+        // parse by canonical coefficients ax+by+c=0
+        // a=3, b=2, c=1
         let L = new Line(3, 2, 1)
 
         let P1 = new Point(-2, 3),
             P2 = new Point(-3, 4)
         expect(L.isOnLine(P1)).to.be.false
         expect(L.isOnLine(P2)).to.be.true
-
-        console.log(
-            (new Polynom(L.OA.y)
-                .add(new Monom(L.d.y).multiply(new Monom('k'))))
-                .reorder('k', true)
-                .tex
-        )
     })
 
 });

package/tests/numexp.test.ts

@@ -31,7 +31,7 @@ describe('Numerical expression', () => { // the tests container
         expect(exprInvalid.isValid).to.be.false
     });
 
-    it('souldd detect invalid expression withouth crahsing', function() {
+    it('souldd detect invalid expression withouth crahsing', function () {
         const exprPourrie = new NumExp('3xsi'),
             exprOk = new NumExp('3xsin(x)')
 
@@ -52,7 +52,7 @@ describe('Numerical expression', () => { // the tests container
         expect(expr2.evaluate({x: 2})).to.be.equal(1)
     });
 
-    it('should calculate sqrt from exp', function(){
+    it('should calculate sqrt from exp', function () {
         let k = new NumExp('nthrt(x,3)')
         expect(k.evaluate({x: -8})).to.be.equal(-2)
         expect(k.evaluate({x: 27})).to.be.equal(3)
@@ -78,4 +78,12 @@ describe('Numerical expression', () => { // the tests container
         let k = new NumExp('ln(3)')
         expect(+k.evaluate().toFixed(6)).to.be.equal(1.098612)
     });
+
+    it('should parse with sqrt and root', () => {
+        const expr1 = new NumExp('sqrt(9)');
+        expect(expr1.evaluate()).to.be.equal(3);
+        
+        const expr2 = new NumExp('nthrt(8,3)');
+        expect(expr2.evaluate()).to.be.equal(2);
+    })
 });

package/esm/maths/expressions/ExpressionTree.d.ts

@@ -1,17 +0,0 @@
-export declare class ExpressionTree {
-    private _root;
-    private _rpn;
-    constructor(value: string);
-    get tex(): string;
-    print(): string;
-    private _parse;
-}
-export declare class ExpressionNode {
-    private _children;
-    private _op;
-    constructor(op: string, ...children: (ExpressionNode | string)[]);
-    get op(): string;
-    get tex(): string;
-    isSingle(): boolean;
-    print(tab: number, stack: string[]): string[];
-}