pimath 0.0.28 → 0.0.32

package/src/maths/expressions/polynomexp.ts

@@ -0,0 +1,309 @@
+import {Polynom, PolynomParsingType} from "../algebra";
+import {Fraction, FractionParsingType} from "../coefficients";
+
+type PolynomExpMathFunctionType = { name: string; fn: Function, tex: string }
+
+export class PolynomExpFactor {
+    constructor(polynom: PolynomParsingType, degree?: FractionParsingType, mathFunction?: PolynomExpMathFunctionType) {
+        this._polynom = new Polynom(polynom)
+        this._degree = new Fraction(degree === undefined ? 1 : degree)
+        this._fn = mathFunction
+        this._powerAsInteger = true
+        this._forceParenthesis = true
+    }
+
+    private _forceParenthesis: boolean
+
+    get forceParenthesis(): boolean {
+        return this._forceParenthesis;
+    }
+
+    set forceParenthesis(value: boolean) {
+        this._forceParenthesis = value;
+    }
+
+    private _fn: PolynomExpMathFunctionType
+
+    get fn(): PolynomExpMathFunctionType {
+        return this._fn;
+    }
+
+    set fn(value: PolynomExpMathFunctionType) {
+        this._fn = value;
+    }
+
+    private _powerAsInteger: boolean
+
+    get powerAsInteger(): boolean {
+        return this._powerAsInteger;
+    }
+
+    set powerAsInteger(value: boolean) {
+        this._powerAsInteger = value;
+    }
+
+    private _polynom: Polynom
+
+    get polynom(): Polynom {
+        return this._polynom;
+    }
+
+    set polynom(value: Polynom) {
+        this._polynom = value;
+    }
+
+    private _degree: Fraction
+
+    get degree(): Fraction {
+        return this._degree;
+    }
+
+    set degree(value: Fraction) {
+        this._degree = value;
+    }
+
+    get tex(): string {
+        let tex
+
+        if (this._degree.isOne() && (this._fn !== undefined || !this._forceParenthesis)) {
+            // If degree is one, no need to add the parenthesis.
+            tex = this._polynom.tex
+        } else {
+            // the degree is not one, add the parenthesis.
+            if (this._powerAsInteger && !this._degree.isRelative()) {
+                // the degree is a fraction and we want natural powers => use sqrt.
+                tex = `\\sqrt${this._degree.denominator !== 2 ? `[ ${this._degree.denominator} ]` : ''}{ ${this._polynom.tex} }^{ ${this._degree.numerator} }`
+            } else if (this.isCoefficient && this.firstCoefficient.isNatural()) {
+                // the value is a natural number (eg 3, 7, ...)
+                tex = this._polynom.tex + this._texDegree
+            } else {
+                // In any other case, add the parenthesis by default
+                tex = `\\left( ${this._polynom.tex} \\right)${this._texDegree}`
+            }
+        }
+
+        if (this._fn !== undefined && this._fn.tex !== undefined) {
+            tex = `${this._fn.tex}\\left( ${tex} \\right)`
+        }
+        return tex
+    }
+
+    get isCoefficient(): boolean {
+        // TODO: Maybe reduce the coefficient if it isn't of degree one.
+        return this._polynom.degree().isZero();
+
+    }
+
+    get firstCoefficient(): Fraction {
+        return this._polynom.monomByDegree().coefficient
+    }
+
+    private get _texDegree(): string {
+        if (this._degree.isOne()) {
+            return ''
+        } else {
+            return `^{ ${this._degree.tfrac} }`
+        }
+    }
+
+    setForceParenthesis(value?: boolean): PolynomExpFactor {
+        this._forceParenthesis = value === undefined || value
+        return this
+    }
+
+    derivative(letter?: string): PolynomExpProduct {
+        if (this._degree.isOne()) {
+            return new PolynomExpProduct(
+                new PolynomExpFactor(this._polynom.clone().derivative(letter))
+            )
+        } else {
+            return new PolynomExpProduct(
+                new PolynomExpFactor(this._degree.clone()),
+                new PolynomExpFactor(this._polynom.clone().derivative(letter)),
+                new PolynomExpFactor(this._polynom.clone(), this._degree.clone().subtract(1))
+            )
+        }
+    }
+}
+
+export class PolynomExpProduct {
+    constructor(...values: PolynomExpFactor[]) {
+        this._factors = values || []
+        this._positive = true
+        this._asPositiveDegree = true
+    }
+
+    private _fn: PolynomExpMathFunctionType
+
+    get fn(): PolynomExpMathFunctionType {
+        return this._fn;
+    }
+
+    set fn(value: PolynomExpMathFunctionType) {
+        this._fn = value;
+    }
+
+    private _factors: PolynomExpFactor[]
+
+    get factors(): PolynomExpFactor[] {
+        return this._factors;
+    }
+
+    set factors(value: PolynomExpFactor[]) {
+        this._factors = value;
+    }
+
+    private _positive: boolean
+
+    get positive(): boolean {
+        return this._positive;
+    }
+
+    set positive(value: boolean) {
+        this._positive = value;
+    }
+
+    private _asPositiveDegree: boolean
+
+    get asPositiveDegree(): boolean {
+        return this._asPositiveDegree;
+    }
+
+    set asPositiveDegree(value: boolean) {
+        this._asPositiveDegree = value;
+    }
+
+    get tex(): string {
+        let parenthesis = this._factors.length>1
+        // Default value
+        let tex = this._factors.map(factor => factor.setForceParenthesis(parenthesis).tex).join(' \\cdot ')
+
+        // Change the value in some cases...
+        if (this._asPositiveDegree) {
+            const numerators = this._factors.filter(x => x.degree.isPositive()),
+                denominators = this._factors.filter(x => x.degree.isNegative())
+
+            let numeratorsAsTex, denominatorsAsTex
+
+            if (denominators.length > 0) {
+                if (numerators.length === 0) {
+                    numeratorsAsTex = [1]
+                } else if (numerators.length === 1) {
+                    numeratorsAsTex = [numerators[0].setForceParenthesis(false).tex]
+                } else {
+                    parenthesis = numerators.length>1
+                    numeratorsAsTex = numerators.map(factor => factor.setForceParenthesis(parenthesis).tex)
+                }
+
+                // Change all denominators degrees to positive.
+                denominators.map(x => x.degree.opposed())
+                if (denominators.length === 1) {
+                    denominatorsAsTex = [denominators[0].setForceParenthesis(false).tex]
+                } else {
+                    parenthesis = denominators.length>1
+                    denominatorsAsTex = denominators.map(factor => factor.setForceParenthesis(parenthesis).tex)
+                }
+                // restore all degrees to negative again.
+                denominators.map(x => x.degree.opposed())
+
+                tex = `\\dfrac{ ${numeratorsAsTex.join(' \\cdot ')} }{ ${denominatorsAsTex.join(' \\cdot ')} }`
+            }
+        }
+
+        // Apply the modification
+        if (this._fn !== undefined && this._fn.name !== undefined && this._fn.name !== '') {
+            tex = `${this._fn.tex}\\left( ${tex} \\right)`
+        }
+        return tex
+    }
+
+    reduce(): PolynomExpProduct {
+        let coefficients = this._factors.filter(factor => factor.isCoefficient),
+            polynoms = this._factors.filter(factor => !factor.isCoefficient)
+
+        let result = new Fraction().one()
+
+        if (coefficients.length > 1) {
+            for (const factor of coefficients) {
+                if (factor.degree.isPositive()) {
+                    result.multiply(factor.polynom.monoms[0].coefficient.pow(factor.degree))
+                } else {
+                    result.divide(factor.polynom.monoms[0].coefficient.pow(factor.degree.clone().abs()))
+                }
+            }
+        } else if (coefficients.length === 1) {
+            result = coefficients[0].polynom.monoms[0].coefficient
+        }
+
+        if (result.isOne()) {
+            this._factors = [...polynoms]
+        } else if (!result.isRelative()) {
+            this._factors = [
+                new PolynomExpFactor(result.numerator),
+                new PolynomExpFactor(result.denominator, -1),
+                ...polynoms
+            ]
+        } else {
+            this._factors = [
+                new PolynomExpFactor(result),
+                ...polynoms
+            ]
+        }
+        return this
+    }
+
+    integrate(letter?: string): PolynomExpProduct {
+        // Handle this kind of case:
+        // A * f' * F^n
+        // A * f' / F^n, n != 1
+        // A * f_1 * f_2 * f_3, where (f_1 * f_2)' = f_3
+        if (this._factors.length === 2) {
+            // Check polynoms degree: one must of one degree less than the other.
+            let d1 = this._factors[0].polynom.degree(letter).value,
+                d2 = this._factors[1].polynom.degree(letter).value
+
+            if (d1 === d2 + 1) {
+                return this._integrateWithInternalDerivative(this._factors[0], this._factors[1], letter)
+            } else if (d1 + 1 === d2) {
+                return this._integrateWithInternalDerivative(this._factors[1], this._factors[0], letter)
+            }
+        }
+        return
+    }
+
+    public applyMathFunction(mathFn: PolynomExpMathFunctionType): PolynomExpProduct {
+        this._fn = mathFn
+        return this
+    }
+
+    private _integrateWithInternalDerivative(P: PolynomExpFactor, Pinternal: PolynomExpFactor, letter?: string): PolynomExpProduct {
+        // Get the internal derivative
+        let internalDerivative: Polynom = P.polynom.clone().derivative(letter)
+
+        // Get the factor.
+        let {quotient, reminder} = Pinternal.polynom.clone().euclidian(internalDerivative)
+
+        if (reminder.isZero() && quotient.degree(letter).isZero()) {
+            // All the conditions are done. Actual situation is
+            // (4x-10)(x^2-5x+7)^9
+            // P1 = (x^2-5x+7), P2 = (2x-5)
+            // => 1/10 * quotient * (x^2-5x+7)^10
+
+            if (P.degree.isEqual(-1)) {
+                return (new PolynomExpProduct(
+                    new PolynomExpFactor(quotient, 1),
+                    new PolynomExpFactor(P.polynom.clone(), 1, {
+                        name: 'ln', tex: '\\ln', fn: (x: number) => Math.log(x)
+                    })
+                ))
+            } else {
+                return new PolynomExpProduct(
+                    new PolynomExpFactor(P.degree.clone().add(1).invert(), 1),
+                    new PolynomExpFactor(quotient, 1),
+                    new PolynomExpFactor(P.polynom.clone(), P.degree.clone().add(1))
+                )
+            }
+        }
+        return
+    }
+}

package/src/maths/geometry/line.ts

@@ -10,8 +10,9 @@ import {Numeric} from "../numeric";
 
 enum LinePropriety {
     None,
-    Parallel,
-    Perpendicular
+    Parallel='parallel',
+    Perpendicular = 'perpendicular',
+    Tangent = 'tangent'
 }
 
 export class Line {
@@ -312,6 +313,9 @@ export class Line {
     isSameAs = (line: Line): Boolean => {
         return this.slope.isEqual(line.slope) && this.height.isEqual(line.height);
     }
+    isVertical = (): Boolean => {
+        return this.slope.isInfinity()
+    }
     simplify = (): Line => {
         let lcm = Numeric.lcm(this._a.denominator, this._b.denominator, this._c.denominator),
             gcd = Numeric.gcd(this._a.numerator, this._b.numerator, this._c.numerator);
@@ -429,6 +433,7 @@ export class Line {
     }
 
     getValueAtX = (value: Fraction|number): Fraction => {
+
         const equ = this.equation.clone().isolate('y'),
             F = new Fraction(value)
 

package/src/maths/geometry/vector.ts

@@ -81,12 +81,20 @@ export class Vector {
             }
 
             // Fractions or a number are give
-            if (values[0].isFraction || !isNaN(values[0])) {
+            if (values[0] instanceof Fraction || !isNaN(values[0])) {
                 this._x = new Fraction(values[0])
             }
-            if (values[1].isFraction || !isNaN(values[1])) {
+            if (values[1] instanceof Fraction || !isNaN(values[1])) {
                 this._y = new Fraction(values[1])
             }
+
+            if(
+                (typeof values[0] === 'object' && !isNaN(values[0].x) && !isNaN(values[0].x)) &&
+                (typeof values[1] === 'object' && !isNaN(values[1].x) && !isNaN(values[1].x))
+            ){
+                this._x = new Fraction(+values[1].x-values[0].x)
+                this._y = new Fraction(+values[1].y-values[0].y)
+            }
         }
 
         return this;

package/src/maths/shutingyard.ts

@@ -1,7 +1,7 @@
 import {loadHighlighter} from "typedoc/dist/lib/utils/highlighter";
 import exp = require("constants");
 
-type tokenType = {
+export type tokenType = {
     [key: string]: {
         precedence: number,
         associative: string,
@@ -13,6 +13,7 @@ export const tokenConstant:{[Key:string]:number} = {
     pi: Math.PI,
     e: Math.exp(1)
 }
+
 export enum ShutingyardType {
     VARIABLE='variable',
     COEFFICIENT='coefficient',
@@ -21,14 +22,17 @@ export enum ShutingyardType {
     FUNCTION = 'function',
     MONOM = 'monom'
 }
+
 export enum ShutingyardMode {
     POLYNOM= 'polynom',
     SET = 'set',
     NUMERIC = 'numeric'
 }
 
+export type Token = { token: string, tokenType: string }
+
 export class Shutingyard {
-    private _rpn: { token: string, tokenType: string }[] = [];
+    private _rpn: Token[] = [];
     readonly _mode: ShutingyardMode;
     private _tokenConfig: tokenType;
     private _tokenConstant: {[Key:string]: number}
@@ -77,7 +81,9 @@ export class Shutingyard {
                 'sin': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
                 'cos': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
                 'tan': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'sqrt': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
             }
+            this._uniformize = false
         } else {
             this._tokenConfig = {
                 '^': {precedence: 4, associative: 'right', type: ShutingyardType.OPERATION},
@@ -85,10 +91,10 @@ export class Shutingyard {
                 '/': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
                 '+': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION},
                 '-': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION},
-                '%': {precedence: 3, associative: 'right', type: ShutingyardType.OPERATION},
-                'sin': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
-                'cos': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
-                'tan': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                // '%': {precedence: 3, associative: 'right', type: ShutingyardType.OPERATION},
+                // 'sin': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                // 'cos': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                // 'tan': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
             }
             this._uniformize = true
         }
@@ -102,7 +108,7 @@ export class Shutingyard {
      * @param expr (string) Expression to analyse
      * @param start (number) CUrrent position in the expr string.
      */
-    NextToken2(expr: string, start: number): [string, number, string] {
+    NextToken(expr: string, start: number): [string, number, string] {
         let token: string, tokenType: string;
         token = '';
         tokenType = '';
@@ -146,7 +152,7 @@ export class Shutingyard {
             if(token===''){
                 // No function found ! Might be a coefficient !
                 if( expr[start].match(/[0-9]/) ) {
-                    if(this._mode === ShutingyardMode.POLYNOM) {
+                    if(this._mode === ShutingyardMode.POLYNOM && false) {
                         token = expr.substring(start).match(/^([0-9.,/]+)/)[0]
                     }else{
                         token = expr.substring(start).match(/^([0-9.,]+)/)[0]
@@ -167,61 +173,6 @@ export class Shutingyard {
         return [token, start + token.length, tokenType];
     }
 
-    // NextToken(expr: string, start: number): [string, number, string] {
-    //     let tokenMatch: string[], token: string, tokenType: string;
-    //
-    //     this.NextToken2(expr, start)
-    //     // Detect a fraction monoms or return empty array
-    //     tokenMatch = (expr.substring(start).match(/^[0-9/a-zA-Z^]+/g)) || [];
-    //
-    //     if (expr.substring(start, start + 3).match(/^(sin|cos|tan)/g)) {
-    //         token = expr.substring(start, start+3)
-    //         tokenType = 'function'
-    //     } else if (tokenMatch.length > 0) {
-    //         token = tokenMatch[0];
-    //         tokenType = 'monom';
-    //     }
-    //     // It's an operation !
-    //     else if (expr[start].match(/[+\-*/^]/g)) {
-    //         token = expr[start];
-    //         tokenType = 'operation';
-    //     } else if (expr[start].match(/[&|!]/g)) {
-    //         token = expr[start];
-    //         tokenType = 'operation';
-    //     }
-    //     // It's an opening parenthese
-    //     else if (expr[start] === '(') {
-    //         token = '(';
-    //         tokenType = '(';
-    //     }
-    //     // It's a closing parenthese
-    //     else if (expr[start] === ')') {
-    //         token = ')';
-    //         tokenType = ')';
-    //     }
-    //     // It's an argument separator for a function
-    //     else if (expr[start] === ',') {
-    //         token = ',';
-    //         tokenType = 'function-argument';
-    //     }
-    //     // It's a monom.
-    //     else {
-    //         // TODO: Actually, negative exposant aren't supported.
-    //         // token = (expr.substring(start).match(/^[\da-z\^]+/g)[0])||'';
-    //         token = tokenMatch[0];
-    //         tokenType = 'monom';
-    //
-    //         if (token === '') {
-    //             token = expr[start];
-    //             tokenType = 'monom';
-    //             console.log('SHUTING YARD - NEXT TOKEN: error at ', start);
-    //         }
-    //     }
-    //
-    //     // console.log(token, start + token.length, tokenType);
-    //     return [token, start + token.length, tokenType];
-    // }
-
     /**
      * Sanitize an expression by adding missing common operation (multiplication between parentheseses)
      * @param expr
@@ -290,7 +241,7 @@ export class Shutingyard {
             }
 
             // Get the next token and the corresponding new (ending) position
-            [token, tokenPos, tokenType] = this.NextToken2(expr, tokenPos);
+            [token, tokenPos, tokenType] = this.NextToken(expr, tokenPos);
 
             switch (tokenType) {
                 case 'monom':

package/tests/algebra/monom.test.ts

@@ -3,8 +3,10 @@ import {Monom} from "../../src/maths/algebra";
 import {Random} from "../../src/maths/random";
 import {describe} from "mocha";
 import {Fraction} from "../../src/maths/coefficients";
+import {Shutingyard} from "../../src/maths/shutingyard";
+import {log} from "util";
 
-describe('Monom tests', () => {
+describe('Monom with integer power', () => {
     it('parsing', () => {
         const M0a = new Monom('3');
         expect(M0a.tex).to.be.equal('3')
@@ -25,10 +27,10 @@ describe('Monom tests', () => {
         expect(M3.tex).to.be.equal('-3x^{-2}')
 
         const M4 = new Monom('3x^(2/3)')
-        expect(M4.tex).to.be.equal('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^{7/3}y^{-5}')
+        expect(M5.tex).to.be.equal('-24x^{\\tfrac{ 7 }{ 3 }}y^{-5}')
     })
 
     it('basic operations', () => {
@@ -66,15 +68,17 @@ describe('Monom tests', () => {
     });
 })
 
-describe('Monom as numerical expression WIP', () => {
+describe('Monom with fraction power', () => {
     it('should create a numerical expression', () => {
-        let M = new Monom()
+        const inputStr: string = '-1/5x^(2/3)'
+        const M = new Monom(inputStr),
+            N = new Monom('7x^(4/5)')
 
-        M.coefficient = new Fraction(3, 7)
-        M.setLetter('3', new Fraction(0.5).reduce())
+        M.multiply(N.clone())
 
         console.log(M.tex)
+
         // TODO: Problem while displaying numerical expression
-        console.log(M.display)
+        expect(M.tex).to.be.equal('-\\dfrac{ 7 }{ 5 }x^{\\tfrac{ 22 }{ 15 }}')
     })
 })

package/tests/algebra/polynom.test.ts

@@ -3,6 +3,7 @@ import {Fraction} from "../../src/maths/coefficients";
 import {Monom, Polynom} from "../../src/maths/algebra";
 import {Random} from "../../src/maths/random";
 import {describe} from "mocha";
+import {Shutingyard} from "../../src/maths/shutingyard";
 
 describe('Polynom tests', () => {
     it('Parse polynom', () => {
@@ -11,6 +12,13 @@ describe('Polynom tests', () => {
         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')
+
+        console.log(P.tex)
+        expect(P.tex).to.be.equal('-\\dfrac{ 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');
@@ -36,7 +44,7 @@ describe('Polynom tests', () => {
         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 5', function () {
+    it('Random Polynom of degree 5', () => {
         let P = Random.polynom({
             degree: 6,
             numberOfMonoms: 3,
@@ -50,7 +58,7 @@ describe('Polynom tests', () => {
         expect(P.degree().value).to.be.equal(6)
     });
 
-    it('should calculate correctly the quotient and reminder', function () {
+    it('should calculate correctly the quotient and reminder', () => {
         let P = new Polynom('(x-3)(x^2+5x-4)+12'),
             D = new Polynom('x-3')
 
@@ -60,3 +68,21 @@ describe('Polynom tests', () => {
         expect(euclidian.reminder.tex).to.be.equal('12')
     });
 })
+
+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+\\dfrac{ 5 }{ 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)
+//     })
+// })

package/tests/numexp.test.ts

@@ -0,0 +1,34 @@
+import {expect} from 'chai';
+import {NumExp} from "../src/maths/expressions/numexp";
+import exp = require("constants");
+
+describe('Numerical expression', () => { // the tests container
+    it('RPN for numerical expression', () => {
+        const RPN = new NumExp('3*x+5').rpn
+        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', '-'])
+    })
+
+    it('Evaluate for numerical expression', () => {
+        const expr = new NumExp('3*x+5')
+        expect(expr.evaluate({x: 5})).to.be.equal(20)
+
+        const expr2 = new NumExp('-3*x^2-5')
+        expect(expr2.evaluate({x: -2})).to.be.equal(-17)
+    })
+
+    it('Evaluation simple mathematical functions', () => {
+        const expr = new NumExp('sqrt(x)')
+        expect(expr.evaluate({x: 9})).to.be.equal(3)
+    })
+
+    it('should detect invalid rpn parsing', function () {
+        const exprValid = new NumExp('3*sin(x)'),
+            exprInvalid = new NumExp('3*sin')
+
+        expect(exprValid.isValid).to.be.true
+        expect(exprInvalid.isValid).to.be.false
+    });
+});

package/tests/polynomexp.test.ts

@@ -0,0 +1,15 @@
+import {describe} from "mocha";
+import {PolynomExpFactor, PolynomExpProduct} from "../src/maths/expressions/polynomexp";
+
+describe('PolynomExpression concepts', () => {
+    it('should display tex', function () {
+        const F1 = new PolynomExpFactor('2x-5', 2.5),
+            F2 = new PolynomExpFactor('2-x', 0.5),
+            PP = new PolynomExpProduct(F1, F2)
+
+        const D = F1.derivative()
+
+        console.log(D.tex)
+        console.log(D.reduce().tex)
+    });
+})