pimath 0.0.125 → 0.0.126

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

@@ -4,8 +4,6 @@ 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 {Numeric} from "../../src/maths/numeric";
 
 describe('Circle', function () {
     it('should calculate the intersection of a circle and a line', function () {
@@ -66,134 +64,120 @@ describe('Circle', 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' : '')
-            )
-        }
-    })
+    
+//     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
-        )
     })
 
 });