pimath 0.0.128 → 0.0.129

package/tests/algebra/monom.test.ts

@@ -1,78 +0,0 @@
-import {expect} from 'chai';
-import {Random} from "../../src/maths/randomization/random";
-import {describe} from "mocha";
-import {Monom} from "../../src/maths/algebra/monom";
-
-describe('Monom with integer power', () => {
-    it('parsing', () => {
-        const M0a = new Monom('3');
-        expect(M0a.tex).to.be.equal('3')
-
-        const M0b = new Monom('x');
-        expect(M0b.tex).to.be.equal('x')
-
-        const M0c = new Monom('3x');
-        expect(M0c.tex).to.be.equal('3x')
-
-        const M1 = new Monom('3x^5');
-        expect(M1.tex).to.be.equal('3x^{5}')
-
-        const M2 = new Monom('2/3x^2yz^3y^4')
-        expect(M2.display).to.be.equal('2/3x^(2)y^(5)z^(3)')
-
-        const M3 = new Monom('-3x^(-2)')
-        expect(M3.tex).to.be.equal('-3x^{-2}')
-
-        const M4 = new Monom('3x^(2/3)')
-        expect(M4.tex).to.be.equal('3x^{\\tfrac{ 2 }{ 3 }}')
-
-        const M5 = new Monom('-3x^(-2/3)y^(-5)8x^3')
-        expect(M5.tex).to.be.equal('-24x^{\\tfrac{ 7 }{ 3 }}y^{-5}')
-    })
-
-    it('basic operations', () => {
-        const M1 = new Monom('3x'),
-            M2 = new Monom('2x')
-
-        expect(M1.clone().add(M2).isEqual(new Monom('5x'))).to.be.true
-        expect(M1.clone().subtract(M2).isEqual(new Monom('x'))).to.be.true
-        expect(M1.clone().multiply(M2).isEqual(new Monom('6x^2'))).to.be.true
-        expect(M1.clone().divide(M2).isEqual(new Monom('3/2'))).to.be.true
-    })
-
-    it('derivative', () => { // the single test
-        const options = new Monom('7x^3'); // this will be your class
-
-        expect(options.tex).to.be.equal('7x^{3}')
-        expect(options.derivative().tex).to.be.equal('21x^{2}');
-    });
-
-    it('integrate', () => { // the single test
-        const options = new Monom('7x^3'); // this will be your class
-        expect(options.primitive().display).to.be.equal('7/4x^(4)');
-    });
-
-    it('randomize', function () {
-        const M = Random.monom({
-            letters: 'xyz',
-            degree: 5,
-            fraction: false,
-            zero: false
-        });
-
-        expect(M.coefficient.isZero()).to.be.false
-        expect(M.degree().value).to.be.greaterThan(0)
-    });
-})
-
-describe('Monom with fraction power', () => {
-    it('should create a numerical expression', () => {
-        const inputStr: string = '-1/5x^(2/3)'
-        const M = new Monom(inputStr),
-            N = new Monom('7x^(4/5)')
-
-        M.multiply(N.clone())
-
-        expect(M.tex).to.be.equal('-\\frac{ 7 }{ 5 }x^{\\tfrac{ 22 }{ 15 }}')
-    })
-})

package/tests/algebra/polynom.test.ts

@@ -1,343 +0,0 @@
-import {expect} from 'chai';
-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";
-
-
-describe('Polynom tests', () => {
-    it('Parse polynom', () => {
-        const options = new Polynom('2x(x+3)^2(x-1)');
-        options.reorder();
-        expect(options.tex).to.be.equal('2x^{4}+10x^{3}+6x^{2}-18x');
-    });
-
-    it('Parse polynom with coefficient as fraction', () => {
-        const P = new Polynom('-3/5x-2')
-
-        expect(P.tex).to.be.equal('-\\frac{ 3 }{ 5 }x-2')
-    })
-
-    it('Tex display', () => {
-        const options = new Polynom('x^2-2x+1');
-        expect(options.tex).to.be.equal('x^{2}-2x+1');
-    });
-
-    it('Evaluate a polynom', function () {
-        const P = new Polynom('2x-3')
-
-        expect(P.evaluate(5).value).to.be.equal(7)
-        expect(P.evaluate(new Fraction('5/3')).display).to.be.equal('1/3')
-    });
-    it('Compare: equals', () => {
-        let F = new Polynom('x+3'),
-            Q = new Polynom('3+x'),
-            P = new Polynom('x-3');
-        expect(F.isEqual(Q)).to.be.true;
-        expect(F.isEqual(P)).to.be.false;
-    })
-    it('Integrate', () => {
-        let F = new Polynom('2x^3-3x^2+x-3'),
-            G = new Polynom('3/5x^2+4')
-
-        expect(F.integrate(0, 2).value).to.be.equal(-4)
-        expect(G.integrate(-3, 3).display).to.be.equal('174/5')
-    })
-    it('Random Polynom of degree 6', () => {
-        let P = Random.polynom({
-            degree: 6,
-            numberOfMonoms: 3,
-            positive: true,
-            fraction: {
-                max: 3
-            }
-        })
-
-        expect(P.length).to.be.equal(3)
-        expect(P.degree().value).to.be.equal(6)
-    });
-
-    it('should calculate correctly the quotient and reminder', () => {
-        let P = new Polynom('(x-3)(x^2+5x-4)+12'),
-            D = new Polynom('x-3')
-
-        let euclidian = P.euclidian(D);
-
-        expect(euclidian.quotient.tex).to.be.equal('x^{2}+5x-4')
-        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()
-        expect(P.tex).to.be.equal('12')
-
-    })
-
-    it('should factorize the polynom', () => {
-        let P = new Polynom('x^2-5x+6')
-
-        P.factorize()
-        expect(P.factors.map(x => x.tex)).to.have.all.members(['x-2', 'x-3'])
-
-        let P2 = new Polynom('x^4-32x^2+256')
-        P2.factorize()
-        expect(P2.factors.map(x => x.tex)).to.have.all.members(['x-4', 'x-4', 'x+4', 'x+4'])
-
-        let P3 = new Polynom('6x^2-48x-8')
-        P3.factorize()
-        expect(P3.factors.map(x => x.tex)).to.have.all.members(['2', '3x^{2}-24x-4'])
-    });
-
-    it('should factorize special polynom', function () {
-        let P = new Polynom('x^6-16x^5-58x^4+1592x^3-1207x^2-37576x+94864')
-
-        P.factorize()
-        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 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)')
-    });
-
-    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
-
-        let R = new Polynom('(x+2)^2')
-        expect(R.isFactorized('(x+2)^2')).to.be.true
-
-        let Q = new Polynom('(x-1)(x+2)')
-        expect(Q.isFactorized('(x+2)(x-1)')).to.be.true
-        expect(Q.isFactorized('x^2+x-2')).to.be.false
-
-        let T = new Polynom('(x-3)(1-x)')
-        expect(T.isFactorized('(x-1)(3-x)')).to.be.true
-        expect(T.isFactorized('(x-1)(x-3)')).to.be.false
-        expect(T.isFactorized('-1(x-1)(x-3)')).to.be.false
-    })
-
-    it('should detect if a polynom with power is factorized', function () {
-        let P = new Polynom('(x-2)^3')
-
-        expect(P.isFactorized('(x-2)^3')).to.be.true
-        expect(P.isFactorized('(x-2)(x-2)(x-2)')).to.be.true
-        expect(P.isFactorized('(x-2)^2(x-2)')).to.be.true
-
-        let Q = new Polynom('(x-2)^4')
-        expect(Q.isFactorized('(x-2)^2(x-2)^2')).to.be.true
-    });
-
-    it('should check if isFactorize with some "soft"', function () {
-        let P = new Polynom('(2x-6)(x+5)')
-
-        expect(P.isFactorized('2(x-3)(x+5)')).to.be.true
-        expect(P.isFactorized('2x-6)(x+5)')).to.be.false
-        expect(P.isFactorized('(2x-6)(x+5)', true)).to.be.true
-
-        let Q = new Polynom('(4x+10)(2x-12)')
-        expect(Q.isFactorized('4(2x+5)(x-6)')).to.be.true
-        expect(Q.isFactorized('(8x+20)(x-6)')).to.be.false
-        expect(Q.isFactorized('(8x+20)(x-6)', true)).to.be.true
-    });
-
-    it('should check if a polynom is developed', function () {
-        let P = new Polynom('x(x+1)')
-
-        expect(P.isDeveloped('x^(2)+x')).true
-        expect(P.isDeveloped('x^2+x')).true
-        expect(P.isDeveloped('x(x+1)')).false
-
-    });
-
-    it('should reorder polynom', function () {
-        let P = new Polynom("3x-4+2y")
-        P.reorder()
-        expect(P.tex).to.be.equal('3x+2y-4')
-    });
-})
-
-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('-5x+3x^{\\tfrac{ 2 }{ 3 }}+\\frac{ 5 }{ 3 }')
-    })
-})
-
-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', ()=>{
-//         const P = new Polynom('-(x+2)(x-1)(x-1)(5x+4)')
-//         const Q = new Polynom('(2+x)^2(1-x)^3')
-//     })
-// })
-
-// TODO: working with roots !
-// describe('WIP : working with roots', ()=>{
-//     it('should parse with roots coefficient',  ()=>{
-//         let P = new Polynom('sqrt(x)-5')
-//
-//         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/rationnal.test.ts

@@ -1,64 +0,0 @@
-import {describe} from "mocha";
-import {Rational} from "../../src/maths/algebra/rational";
-import {Polynom} from "../../src/maths/algebra/polynom";
-import {expect} from "chai";
-
-describe('Rational tests', () => {
-    it('should calculate correctly the limits to a value', () => {
-
-        const FR = new Rational(
-            new Polynom('(x+2)'),
-            new Polynom('(x-4)(x+2)')
-        )
-
-        expect(FR.limits(4).tex).to.be.equal("+\\infty")
-        expect(FR.limits(4, 'below').tex).to.be.equal("-\\infty")
-        expect(FR.limits(4, 'above').tex).to.be.equal("+\\infty")
-        expect(FR.limits(-2).tex).to.be.equal("-\\frac{ 1 }{ 6 }")
-    })
-    it('should calculate the limits to Infinity', () => {
-        const FR0 = new Rational(
-            new Polynom('3'),
-            new Polynom('x-5')
-        )
-        const FR2 = new Rational(
-            new Polynom('2x+5'),
-            new Polynom('x-5')
-        )
-
-        const FR3 = new Rational(
-            new Polynom('2x^2+5'),
-            new Polynom('x-5')
-        )
-
-        expect(FR0.limits(Infinity).value).to.be.equal(0)
-        expect(FR0.limits(-Infinity).value).to.be.equal(0)
-
-        expect(FR2.limits(Infinity).value).to.be.equal(2)
-        expect(FR2.limits(-Infinity).value).to.be.equal(2)
-
-        expect(FR3.limits(Infinity).value).to.be.equal(Infinity)
-        expect(FR3.limits(-Infinity).value).to.be.equal(-Infinity)
-    })
-
-
-    it('should calculate the derivative', function () {
-        const FR = new Rational(
-            new Polynom('x^2+5x+6'),
-            new Polynom('x-3')
-        )
-
-        FR.derivative()
-    });
-
-    it('should test', function () {
-        let P = new Rational('245(x-2)', '(3x-5)(2x-3)')
-
-        expect(P.plotFunction).to.be.equal("(245*x-490)/(6*x^(2)-19*x+15)")
-    });
-
-    it('should reduce withouth creating fraction', function () {
-        let P = new Rational('4(x+1)', '(x+1)(x-3)')
-        expect(P.reduce().display).to.be.equal('(4)/(x-3)')
-    });
-})

package/tests/algebra/study.test.ts

@@ -1,48 +0,0 @@
-import {describe} from "mocha";
-import {Rational} from "../../src/maths/algebra/rational";
-import {RationalStudy} from "../../src/maths/algebra/study/rationalStudy";
-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')
-            new Rational('(3x-2)(x-3)(x+4)', 'x^2-5x+6')
-        )
-        let AO = study.asymptotes.filter(x => x.type === ASYMPTOTE.SLOPE)[0]
-    });
-
-    it('should create draw code block', function () {
-        const study = new RationalStudy(
-            new Rational("(3x-4)(2x+5)", "(x-4)(x+4)")
-        )
-
-        expect(study.drawCode()).to.be.equal("f(x)=(6*x^(2)+7*x-20)/(x^(2)-16)\n" +
-            "av_1=line x=-4->red,dash\n" +
-            "av_3=line x=4->red,dash\n" +
-            "ah=line y=6->orange,dash\n" +
-            "M_6(-20.950583847231826,5.832940216581962)*\n" +
-            "M_7(-0.7637018670538883,1.4170597834180383)*\n" +
-            "Z_8(-2.5,0)*\n" +
-            "Z_9(1.3333333333333333,0)*")
-    });
-
-    it('should get the before/after state of asymptotes', function () {
-        const study = new RationalStudy(
-            new Rational("x+5", "x-3")
-            // new Rational("x^2+5", "(x-3)^2")
-        )
-
-        expect(study.asymptotes[0].position).to.have.all.members(["LB", "RT"])
-    });
-
-    it('should get only the domain and the signs of a rational', function () {
-        const R = new Rational('x-3', 'x^2-4')
-        const study = R.study('\\delta(x),d,signs')
-
-        expect(study.domain).to.be.equal('\\mathbb{R}\\setminus\\left\\{-2;2\\right\\}')
-        expect(study.signs.signs[0]).to.have.all.members(['', '-', 't', '-', 't', '-', 'z', '+', ''])
-    });
-})

package/tests/coefficients/fraction.test.ts

@@ -1,131 +0,0 @@
-import {expect} from "chai";
-import {Fraction} from "../../src/maths/coefficients/fraction";
-import {describe} from "mocha";
-import {Random} from "../../src/maths/randomization/random";
-
-
-describe('Fraction tests', () => { // the tests container
-
-    it('Tex display', () => { // the single test
-        const options = new Fraction(2, 5); // this will be your class
-        expect(options.frac).to.be.equal('\\frac{ 2 }{ 5 }');
-    });
-
-    it('Compare: equals', () => {
-        let F = new Fraction(1, 3),
-            Q = new Fraction(2, 6),
-            P = new Fraction(2, 5);
-        expect(F.isEqual(Q)).to.be.true;
-        expect(F.isEqual(P)).to.be.false;
-    })
-
-    it('Operation: sum of two fraction', () => {
-        let F = new Fraction(1, 3),
-            Q = new Fraction(2, 7);
-
-        F.add(Q);
-
-        expect(F.numerator).to.be.equal(13);
-        expect(F.denominator).to.be.equal(21);
-    })
-
-    it('Reduced', () => {
-        let F = new Fraction(2, 5),
-            Q = new Fraction(2, 6)
-
-        expect(F.isReduced()).to.be.true
-        expect(Q.isReduced()).to.be.false
-    })
-
-    it('Should parse a number with lots of decimals', ()=>{
-        let A = 3.45,
-            B = 3.3333333333333,
-            C = 5.314171717171717
-
-        let FA = new Fraction(A),
-            FB = new Fraction(B, 1),
-            FC = new Fraction(C, 2)
-
-        expect(FA.display).to.be.equal('69/20')
-        expect(FB.display).to.be.equal('10/3')
-        expect(FC.display).to.be.equal('526103/99000')
-    })
-})
-
-describe("Fraction static functions", ()=>{
-    it('should sort fractions', function () {
-        let list = [
-            new Fraction('3.5'),
-            new Fraction('-2.5'),
-            new Fraction('3.1'),
-            new Fraction('3.54'),
-            new Fraction('1.5')
-        ]
-
-        expect(Fraction.sort(list).map(x=>x.value)).to.eql([ -2.5, 1.5, 3.1, 3.5, 3.54 ])
-    });
-
-    it('should make a list of fractions unique', function () {
-        let list = [
-            new Fraction('3.5'),
-            new Fraction('-2.5'),
-            new Fraction('7/2'),
-            new Fraction('3.50'),
-            new Fraction('1.5')
-        ]
-
-        expect(Fraction.unique(list, true).map(x=>x.value)).to.be.eql([ -2.5, 1.5, 3.5 ])
-
-    });
-
-    it('shoudl get the average of fractions', function() {
-        let list = [
-            new Fraction('3.5'),
-            new Fraction('-2.5'),
-            new Fraction('7/2'),
-            new Fraction('3.50'),
-            new Fraction('1.5')
-        ]
-
-        expect(Fraction.average(...list).tex).to.be.equal('\\frac{ 19 }{ 10 }')
-    })
-
-    it('should multiply and not reduce', function () {
-        let list = [
-            new Fraction('1/2'),
-            new Fraction('4/3'),
-            2.5,
-            3
-        ]
-
-        expect(new Fraction().xMultiply(...list).display).to.be.equal("60/12")
-    });
-})
-
-describe("Evaluate fraction", () => {
-    it('should evaluate and convert to decimal if not exact', function () {
-        let F = new Fraction(Math.sqrt(2))
-
-        expect(F.isApproximative()).to.be.true
-        expect(F.isExact()).to.be.false
-
-        let G = new Fraction('1/7')
-        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;
-    });
-})