pimath 0.0.89 → 0.0.91

package/src/maths/algebra/equation.ts

@@ -629,69 +629,93 @@ export class Equation {
                     // -b +- coeff\sqrt{radical}
                     // -------------------------
                     //           2a
-                    let gcd = Numeric.gcd(b, 2 * a, nthDelta.coefficient);
+                    let gcd = Numeric.gcd(b, 2 * a, nthDelta.coefficient),
+                        am = a/gcd, bm = b/gcd
                     nthDelta.coefficient = nthDelta.coefficient / gcd;
 
-                    // TODO: Can i delete the next line ?
-                    // let deltaC = nthDelta.coefficient, deltaR = nthDelta.radical;
-                    if (b !== 0) {
-                        if (2 * a / gcd === 1) {
-                            this._solutions = [
-                                {
-                                    tex: `${-b / gcd} - ${nthDelta.tex}`,
-                                    value: realX1,
-                                    exact: false // TODO: implement exact value with nthroot
-                                },
-                                {
-                                    tex: `${-b / gcd} + ${nthDelta.tex}`,
-                                    value: realX2,
-                                    exact: false
-                                },
-
-                            ]
-                        } else {
-                            this._solutions = [
-                                {
-                                    tex: `\\frac{${-b / gcd} - ${nthDelta.tex} }{ ${2 * a / gcd} }`,
-                                    value: realX1,
-                                    exact: false
-                                },
-                                {
-                                    tex: `\\frac{${-b / gcd} + ${nthDelta.tex} }{ ${2 * a / gcd} }`,
-                                    value: realX2,
-                                    exact: false
-                                },
-                            ]
-                        }
-                    } else {
-                        if (2 * a / gcd === 1) {
-                            this._solutions = [
-                                {
-                                    tex: `- ${nthDelta.tex}`,
-                                    value: realX1,
-                                    exact: false
-                                },
-                                {
-                                    tex: `${nthDelta.tex}`,
-                                    value: realX2,
-                                    exact: false
-                                },
-                            ]
-                        } else {
-                            this._solutions = [
-                                {
-                                    tex: `\\frac{- ${nthDelta.tex} }{ ${2 * a / gcd} }`,
-                                    value: realX1,
-                                    exact: false
-                                },
-                                {
-                                    tex: `\\frac{${nthDelta.tex} }{ ${2 * a / gcd} }`,
-                                    value: realX2,
-                                    exact: false
-                                },
-                            ]
-                        }
+                    if(a<0){
+                        am = -am
+                        bm = -bm
+                    }
+
+                    let tex1 = "", tex2 = ""
+
+                    tex1 = `${bm!==0?((-bm) + ' - '):''}${nthDelta.tex}`
+                    tex2 = `${bm!==0?((-bm) + ' + '):''}${nthDelta.tex}`
+
+                    if(am!==1){
+                        tex1 = `\\frac{ ${tex1} }{ ${2*am} }`
+                        tex2 = `\\frac{ ${tex2} }{ ${2*am} }`
                     }
+
+                    this._solutions = [
+                        {
+                            tex: tex1, value: realX1, exact: false
+                        },
+                        {
+                            tex: tex2, value: realX2, exact: false
+                        },
+                    ]
+
+
+                    // if (b !== 0) {
+                    //     if (2 * a / gcd === 1) {
+                    //         this._solutions = [
+                    //             {
+                    //                 tex: `${-b / gcd} - ${nthDelta.tex}`,
+                    //                 value: realX1,
+                    //                 exact: false // TODO: implement exact value with nthroot
+                    //             },
+                    //             {
+                    //                 tex: `${-b / gcd} + ${nthDelta.tex}`,
+                    //                 value: realX2,
+                    //                 exact: false
+                    //             },
+                    //
+                    //         ]
+                    //     } else {
+                    //         this._solutions = [
+                    //             {
+                    //                 tex: `\\frac{${-b / gcd} - ${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                    //                 value: realX1,
+                    //                 exact: false
+                    //             },
+                    //             {
+                    //                 tex: `\\frac{${-b / gcd} + ${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                    //                 value: realX2,
+                    //                 exact: false
+                    //             },
+                    //         ]
+                    //     }
+                    // } else {
+                    //     if (2 * a / gcd === 1) {
+                    //         this._solutions = [
+                    //             {
+                    //                 tex: `- ${nthDelta.tex}`,
+                    //                 value: realX1,
+                    //                 exact: false
+                    //             },
+                    //             {
+                    //                 tex: `${nthDelta.tex}`,
+                    //                 value: realX2,
+                    //                 exact: false
+                    //             },
+                    //         ]
+                    //     } else {
+                    //         this._solutions = [
+                    //             {
+                    //                 tex: `\\frac{- ${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                    //                 value: realX1,
+                    //                 exact: false
+                    //             },
+                    //             {
+                    //                 tex: `\\frac{${nthDelta.tex} }{ ${2 * a / gcd} }`,
+                    //                 value: realX2,
+                    //                 exact: false
+                    //             },
+                    //         ]
+                    //     }
+                    // }
                 } else {
                     // -b +- d / 2a
                     const S1 = new Fraction(-b - nthDelta.coefficient, 2 * a).reduce(),

package/src/maths/coefficients/fraction.ts

@@ -231,7 +231,7 @@ export class Fraction {
                     // The given value is a float number
                     // Get the number of decimals after the float sign
                     let [unit, decimal] = (value.toString()).split('.')
-                    let p: number = decimal.length;
+                    let p: number = decimal?decimal.length:0;
 
                     // Detect if the decimal part is periodic or not...
 

package/src/maths/geometry/line.ts

@@ -73,6 +73,24 @@ export class Line {
         }
     }
 
+    get display(): { canonical: string, mxh: string, parametric: string } {
+        // canonical    =>  ax + by + c = 0
+        // mxh          =>  y = -a/b x - c/b
+        // parametric   =>  (xy) = OA + k*d // not relevant in display mode.
+
+        let canonical = this.equation;
+        // Make sur the first item is positive.
+        if (this._a.isNegative()) {
+            canonical.multiply(-1);
+        }
+
+        return {
+            canonical: canonical.display,
+            mxh: this.slope.isInfinity() ? 'x=' + this.OA.x.display : 'y=' + new Polynom().parse('x', this.slope, this.height).display,
+            parametric: ""
+        }
+    }
+
     get a(): Fraction {
         return this._a;
     }

package/src/maths/numeric.ts

@@ -80,6 +80,11 @@ export class Numeric{
         return Math.abs(g);
     }
 
+    static divideNumbersByGCD(...values: number[]): number[]{
+        let gcd = Numeric.gcd(...values)
+
+        return values.map(x=>x/gcd)
+    }
     /**
      * Least Common Multiple
      * @param values: list of numbers
@@ -137,7 +142,6 @@ export class Numeric{
                 mod0 = mod.match(/0+$/g)
 
             if(mod0 && mod0[0].length>= number_of_digits){
-                // The value can be changed. Remove all zeros!
                 return +((value+epsilon).toString().split(mod0[0])[0])
             }
         }

package/src/maths/randomization/rndFraction.ts

@@ -35,7 +35,11 @@ export class rndFraction extends randomCore {
         if(this._config.natural){
             Q.denominator = 1
         }else {
-            Q.denominator = Random.number(1, this._config.max)
+            let securityCount = 0
+            while(Q.isRelative() && securityCount<10) {
+                Q.denominator = Random.number(1, this._config.max)
+                securityCount++
+            }
         }
 
         return this._config.reduced?Q.reduce():Q

package/tests/algebra/equation.test.ts

@@ -1,6 +1,8 @@
 import {describe} from "mocha";
 import {expect} from "chai";
 import {Equation} from "../../src/maths/algebra/equation";
+import {PiMath} from "../../src";
+import exp = require("constants");
 
 describe('Equations tests', () => {
     it('should get the solutions', () => {
@@ -33,4 +35,16 @@ describe('Equations tests', () => {
             '\\frac{-7 + \\sqrt{669} }{ 10 }'
         ] )
     })
+
+    it('should resolve an equation of second degree', ()=>{
+        let P = new Equation('-10x^2-8x+8=0')
+        P.solve()
+        expect(P.solutions[0].tex).to.have.oneOf(['\\frac{ -2 - 2\\sqrt{6} }{ 5 }', '\\frac{ -2 + 2\\sqrt{6} }{ 5 }'])
+    })
+
+    it('should solve this equation please', function () {
+        let P = new Equation("2/7(3x+5)=9-(3-x)/7")
+        P.solve()
+        console.log(P.solutions.map(x=>x.tex))
+    });
 })

package/tests/coefficients/fraction.test.ts

@@ -1,6 +1,8 @@
 import {expect} from "chai";
 import {Fraction} from "../../src/maths/coefficients/fraction";
 import {describe} from "mocha";
+import {Random} from "../../src/maths/randomization/random";
+import exp = require("constants");
 
 describe('Fraction tests', () => { // the tests container
 
@@ -111,4 +113,19 @@ describe("Evaluate fraction", () => {
         expect(G.isApproximative()).to.be.false
         expect(G.isExact()).to.be.true
     });
+})
+
+describe('Generate function', ()=>{
+    it('should generate a non natural fraction', function () {
+        let F, result = true
+
+        for(let i=0; i<100; i++){
+            F  = Random.fraction()
+            if(!F.isRelative()){
+                result = false
+                break
+            }
+        }
+        expect(F.isNatural()).to.be.false;
+    });
 })

package/tests/custom.test.ts

@@ -0,0 +1,31 @@
+import {Random} from "../src/maths/randomization/random";
+import {Fraction} from "../esm/maths/coefficients/fraction";
+import {NthRoot} from "../esm/maths/coefficients/nthRoot";
+
+describe('Custom test', () => { // the tests container
+    it('Build sqrt value', () => {
+
+        let a = 1, b = 27, c = 50
+
+        a = Random.number(2,20)
+        b = Random.number(2,20)
+        c = Random.number(2,20)
+
+        let nthB = new NthRoot(b).reduce(),
+            nthC = new NthRoot(c).reduce(),
+            nthD = new NthRoot(nthB.radical * nthC.radical).reduce(),
+            F = new Fraction(a*nthB.coefficient*nthD.coefficient, nthC.radical*nthC.coefficient).reduce(),
+            answer = ''
+
+        if(F.numerator>1){
+            answer = `${F.numerator}`
+        }
+        if(nthD.radical>1){
+            answer = `${answer}sqrt${nthD.radical}`
+        }
+        if(F.denominator>1){
+            answer = `${answer}/${F.denominator}`
+        }
+        console.log(`${a}sqrt${b}/sqrt${c}`, answer)
+    })
+});

package/tests/numeric.test.ts

@@ -1,14 +1,21 @@
 import {Numeric} from "../src/maths/numeric";
 import {expect} from "chai";
-import {Random} from "../src/maths/randomization/random";
 
 describe('Numeric', () => { // the tests container
     it('Correct number', () => {
         const a = 0.1 + 0.2
-        console.log(a)
+        expect(Numeric.numberCorrection(a)).to.be.equal(0.3)
+        const b = Math.pow(10, -5)
 
-        console.log(Random.prime(20))
+        expect(Numeric.numberCorrection(b, 1,12)).to.be.equal(0.00001)
+    })
 
-        expect(Numeric.numberCorrection(a)).to.be.equal(0.3)
+
+    it('should simplify numbers by the gcd', () => {
+        let a = 12, b = 15, c = 33, d = 303;
+
+        [a, b, c, d] = Numeric.divideNumbersByGCD(a, b, c, d)
+
+        expect([a, b, c, d]).to.have.all.members([4, 5, 11, 101])
     })
 });