pimath 0.0.75 → 0.0.78

package/src/maths/numeric.ts

@@ -104,4 +104,71 @@ export class Numeric{
 
         return triplets
     }
+
+    static numberCorrection(value: number){
+        // Must modify the number if it's like:
+        // a: 3.0000000000000003
+        // b: 3.9999999999999994
+        // remove the last character
+        // check if around n last characters are either 0 or 9
+        // if it is, 'round' the number.
+
+        function extractDecimalPart(valueToExtract: number){
+            let decimal = valueToExtract.toString()
+
+            if (!decimal.includes('.')) {
+                return ''
+            }
+
+            decimal = decimal.split('.')[1]
+
+            return decimal.substring(0, decimal.length - 2)
+        }
+
+
+        const epsilon = 0.00000000000001,
+            number_of_digits = 6
+
+        const decimal = extractDecimalPart(value)
+        if(decimal===''){return value}
+
+        const n9 = decimal.match(/9+$/g)
+        const n0 = decimal.match(/0+$/g)
+
+        if (n9 && n9[0].length >= number_of_digits) {
+            // New tested values.
+            const mod = extractDecimalPart(value + epsilon),
+                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])
+            }
+        }
+
+        if (n0 && n0[0].length >= number_of_digits) {
+            // New tested values.
+            const mod = extractDecimalPart(value - epsilon),
+                mod9 = mod.match(/9+$/g)
+
+            if(mod9 && mod9[0].length>= number_of_digits){
+                // The value can be changed. Remove all nines!
+                return +(value.toString().split(n0[0])[0])
+            }
+        }
+
+        return value
+    }
+
+    static periodic(value: number):number{
+        if(Number.isSafeInteger(value)){return 0}
+
+        // Assume it's with decimal.
+        let decimal = (value.toString()).split('.')[0]
+
+        // The decimal part is limited
+        if(decimal.length<10){return 0}
+
+        // Find the periodic if it exists.
+    }
 }

package/src/maths/randomization/random.ts

@@ -42,7 +42,7 @@ export namespace Random {
         return rndHelpers.randomItem(arr)
     }
 
-    export function shuffle(arr: any[]): any {
-        rndHelpers.shuffleArray(arr)
+    export function shuffle(arr: any[]): any[] {
+        return rndHelpers.shuffleArray(arr)
     }
 }

package/tests/algebra/polynom.test.ts

@@ -3,6 +3,7 @@ import {Random} from "../../src/maths/randomization/random";
 import {describe} from "mocha";
 import {Polynom} from "../../src/maths/algebra/polynom";
 import {Fraction} from "../../src/maths/coefficients/fraction";
+import exp = require("constants");
 
 
 describe('Polynom tests', () => {
@@ -89,17 +90,20 @@ describe('Polynom tests', () => {
         expect(P.factors.map(x => x.tex)).to.have.all.members(['x-4', 'x-4', 'x+7', 'x+7', 'x-11', 'x-11'])
     });
 
-    it('should factorize and regroupe', function () {
+    it('should factorize and regroup', function () {
         let P = new Polynom('7x(x-3)(x+5)(x^2-9)3x')
         P.factorize()
         expect(P.texFactors).to.be.equal('21x^{2}\\left( x+3 \\right)\\left( x-3 \\right)^{ 2 }\\left( x+5 \\right)')
+
+        const P2 = new Polynom('-2x^3+18x')
+        P2.factorize()
+        expect(P2.texFactors).to.be.equal('-2x\\left( x+3 \\right)\\left( x-3 \\right)')
     });
 })
 
 describe('Polynom parsing with rational power', () => {
     it('should parse with rational powers', () => {
         const P = new Polynom('3x^(2/3)-5x+5/3');
-
         expect(P.tex).to.be.equal('3x^{\\tfrac{ 2 }{ 3 }}-5x+\\frac{ 5 }{ 3 }')
     })
 })

package/tests/coefficients/fraction.test.ts

@@ -35,7 +35,17 @@ describe('Fraction tests', () => { // the tests container
         expect(Q.isReduced()).to.be.false
     })
 
+    it('Should parse a number with lots of decimals', ()=>{
+        let A = 3.45,
+            B = 3.333333333333322,
+            C = 5.314171717171717
 
+        let FA = new Fraction(A),
+            FB = new Fraction(B),
+            FC = new Fraction(C)
+
+        console.log(FA.tex, FB.tex, FC.tex)
+    })
 })
 
 describe("Fraction static functions", ()=>{
@@ -76,7 +86,7 @@ describe("Fraction static functions", ()=>{
         expect(Fraction.average(...list).tex).to.be.equal('\\frac{ 19 }{ 10 }')
     })
 
-    it('should multiply and notreduce', function () {
+    it('should multiply and not reduce', function () {
         let list = [
             new Fraction('1/2'),
             new Fraction('4/3'),
@@ -100,7 +110,5 @@ describe("Evaluate fraction", () => {
         let G = new Fraction('1/7')
         expect(G.isApproximative()).to.be.false
         expect(G.isExact()).to.be.true
-
-        console.log(G.tex, G.value)
     });
 })

package/tests/expressions/expressiontree.test.ts

@@ -0,0 +1,11 @@
+import {ExpressionTree} from "../../src/maths/expressions/ExpressionTree";
+
+describe('Expressions test', () => { // the tests container
+    it('Parsing tree', () => {
+        // let ET = new ExpressionTree('3(x-4)^2')
+        let ET = new ExpressionTree('3(x-7)^2-5sqrt(5x-3)')
+
+        console.log(ET.tex)
+    })
+
+});

package/tests/numexp.test.ts

@@ -1,6 +1,6 @@
 import {expect} from 'chai';
 import {NumExp} from "../src/maths/expressions/numexp";
-import exp = require("constants");
+import {Numeric} from "../src/maths/numeric";
 
 describe('Numerical expression', () => { // the tests container
     it('RPN for numerical expression', () => {
@@ -8,7 +8,7 @@ describe('Numerical expression', () => { // the tests container
         expect(RPN.map(x => x.token)).to.have.all.members(['3', 'x', '*', '5', '+'])
 
         const RPN2 = new NumExp('-3*x^2-5').rpn
-        expect(RPN2.map(x=>x.token)).to.have.all.members(['3', 'x', '2', '^', '*', '-', '5', '-'])
+        expect(RPN2.map(x => x.token)).to.have.all.members(['3', 'x', '2', '^', '*', '-', '5', '-'])
     })
 
     it('Evaluate for numerical expression', () => {
@@ -34,9 +34,10 @@ describe('Numerical expression', () => { // the tests container
 
     it('should parse without mult sign', function () {
 
-        const expr = new NumExp('3x+5')
+        let a = 1 / 5
 
-        // console.log(expr.rpn)
+        console.log(a, Numeric.numberCorrection(a))
 
+        // console.log(expr.rpn)
     });
 });