pimath 0.0.64 → 0.0.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pimath",
-  "version": "0.0.64",
+  "version": "0.0.67",
   "description": "A math library for teacher :)",
   "scripts": {
     "test": "mocha -r ts-node/register 'tests/**/*.test.ts'",

package/src/maths/algebra/equation.ts

@@ -576,9 +576,9 @@ export class Equation {
             } else {
                 // Must handle the case if the m1 monom is negative.
                 if ((this.isGreater() && m1.sign() === 1) || (!this.isGreater() && m1.sign() === -1)) {
-                    s = `\\left${this.isAlsoEqual() ? '\\[' : '\\]'}${v};+\\infty\\right\\[`;
+                    s = `\\left${this.isAlsoEqual() ? '\\[' : '\\]'}${v.tex};+\\infty\\right\\[`;
                 } else {
-                    s = `\\left\\]-\\infty;${v} \\right\\${this.isAlsoEqual() ? '\\]' : '\\['}`;
+                    s = `\\left\\]-\\infty;${v.tex} \\right\\${this.isAlsoEqual() ? '\\]' : '\\['}`;
                 }
             }
             this._solutions = [{

package/src/maths/algebra/polynom.ts

@@ -259,6 +259,7 @@ export class Polynom {
         this._factors = []
         this.mark_as_dirty()
 
+        // TODO: allow to enter a liste of Fraction (a, b, c, ...) to make a polynom ax^n + bx^(n-1) + cx^(n-2) + ...
         if (typeof inputStr === 'string') {
             return this._parseString(inputStr, ...values)
         } else if (

package/src/maths/algebra/study/rationalStudy.ts

@@ -36,7 +36,6 @@ export class RationalStudy extends Study {
     }
 
     makeZeroes(): IZero[] {
-        console.log('GETTING ZEROES')
         return this._getZeroes(this.fx)
     };
 
@@ -68,11 +67,13 @@ export class RationalStudy extends Study {
             }
 
             asymptotes.push({
+                fx: null,
                 type: Ztype,
                 tex: tex,
                 zero: zero,
                 limits: `\\lim_{x\\to${zero.tex} }\\ f(x) = \\pm\\infty`,
-                deltaX: null
+                deltaX: null,
+                tableOfSign: null
             })
         })
 
@@ -80,35 +81,45 @@ export class RationalStudy extends Study {
         let NDegree = this.fx.numerator.degree(),
             DDegree = this.fx.denominator.degree()
         if (NDegree.isEqual(DDegree)) {
-            let H = this.fx.numerator.monomByDegree().coefficient.clone().divide(this.fx.denominator.monomByDegree().coefficient).tex
+            let H = this.fx.numerator.monomByDegree().coefficient.clone().divide(this.fx.denominator.monomByDegree().coefficient),
+                Htex = H.tex
+
+            let {reminder} = reduced.euclidian(),
+                deltaX = new Rational(reminder, reduced.denominator)
 
-            let {reminder} = reduced.euclidian()
 
             asymptotes.push({
+                fx: new Polynom(H),
                 type: ASYMPTOTE.HORIZONTAL,
-                tex: `y=${H}`,
+                tex: `y=${Htex}`,
                 zero: null,
-                limits: `\\lim_{x\\to\\infty}\\ f(x) = ${H}`,
-                deltaX: new Rational(reminder, reduced.denominator)
+                limits: `\\lim_{x\\to\\infty}\\ f(x) = ${Htex}`,
+                deltaX,
+                tableOfSign: this._getSigns(deltaX)
             })
         } else if (DDegree.greater(NDegree)) {
             asymptotes.push({
+                fx: new Polynom('0'),
                 type: ASYMPTOTE.HORIZONTAL,
                 tex: `y=0`,
                 zero: null,
                 limits: `\\lim_{x\\to\\infty}\\ f(x) = ${0}`,
-                deltaX: null
+                deltaX: null,
+                tableOfSign: null
             })
         } else if (NDegree.value - 1 === DDegree.value) {
             // Calculate the slope
-            let {quotient, reminder} = reduced.euclidian()
+            let {quotient, reminder} = reduced.euclidian(),
+                deltaX = new Rational(reminder, reduced.denominator)
 
             asymptotes.push({
+                fx: quotient.clone(),
                 type: ASYMPTOTE.SLOPE,
                 tex: `y=${quotient.tex}`,
                 zero: null,
                 limits: ``,
-                deltaX: new Rational(reminder, reduced.denominator)
+                deltaX: new Rational(reminder, reduced.denominator),
+                tableOfSign: this._getSigns(deltaX)
             })
         }
 
@@ -119,7 +130,6 @@ export class RationalStudy extends Study {
         let dx = this.fx.clone().derivative(),
             tos = this._getSigns(dx, this._getZeroes(dx), TABLE_OF_SIGNS.GROWS)
 
-        console.log(tos.factors.length, tos.signs.length)
         let result = this.makeGrowsResult(tos)
         tos.signs.push(result.growsLine)
         tos.extremes = result.extremes
@@ -175,11 +185,15 @@ export class RationalStudy extends Study {
         return zeroes
     }
 
-    private _getSigns(fx: Rational, zeroes: IZero[], typeOfTable?: TABLE_OF_SIGNS): ITableOfSigns {
+    private _getSigns(fx: Rational, zeroes?: IZero[], typeOfTable?: TABLE_OF_SIGNS): ITableOfSigns {
         // Factorize the rational
         let signs: (string[])[] = [],
             factors: Polynom[] = []
 
+        if (zeroes === undefined) {
+            zeroes = this._getZeroes(fx)
+        }
+
         fx.numerator.factors.forEach(factor => {
             signs.push(this.makeOneLineForSigns(factor, zeroes, ZEROTYPE.ZERO))
             factors.push(factor.clone())

package/src/maths/algebra/study.ts

@@ -8,6 +8,7 @@ import {ISolution} from "./equation";
 import {Polynom} from "./polynom";
 import {Fraction} from "../coefficients/fraction";
 import {Point} from "../geometry/point";
+import {NumExp} from "../expressions/numexp";
 
 export type StudyableFunction = Rational
 
@@ -31,11 +32,13 @@ export enum ASYMPTOTE {
 }
 
 export interface IAsymptote {
+    fx: Polynom,
     deltaX: StudyableFunction
     limits: string,
     tex: string,
     type: ASYMPTOTE,
     zero: IZero,
+    tableOfSign: ITableOfSigns
 }
 
 export enum FUNCTION_EXTREMA {
@@ -69,9 +72,9 @@ export interface ITableOfSigns {
 }
 
 export enum TABLE_OF_SIGNS {
-    DEFAULT,
-    GROWS,
-    VARIATIONS
+    SIGNS = "signs",
+    GROWS = "grows",
+    VARIATIONS = "variatins"
 }
 
 /**
@@ -251,6 +254,9 @@ export class Study {
                     xTex: string, yTex: string,
                     pointType: FUNCTION_EXTREMA
 
+                // TODO: NumExp should parse something that isn't yet plotFunction
+                let exp = new NumExp(this.fx.plotFunction)
+
                 if (zero instanceof Fraction) {
                     let value: Fraction = zero,
                         evalY = this.fx.evaluate(value)
@@ -261,7 +267,7 @@ export class Study {
                     yTex = evalY.tex
                 } else {
                     x = zeroes[i].value
-                    y = this.fx.evaluate(zeroes[i].value).value
+                    y = exp.evaluate({x})
 
                     xTex = x.toFixed(2)
                     yTex = y.toFixed(2)
@@ -317,7 +323,7 @@ export class Study {
 
     makeSigns(): ITableOfSigns {
         return {
-            type: TABLE_OF_SIGNS.DEFAULT,
+            type: TABLE_OF_SIGNS.SIGNS,
             fx: null,
             factors: [],
             zeroes: [],
@@ -390,4 +396,41 @@ export class Study {
 
         return tex
     }
+
+    drawCode = (): string => {
+        // Function as string
+        let code = `f(x)=${this.fx.plotFunction}`
+
+        // Asymptotes
+        let i: number = 1
+        this.asymptotes.forEach(asymptote => {
+            if (asymptote.type === ASYMPTOTE.VERTICAL) {
+                code += `\nav_${i}=line x=${asymptote.zero.value}->red,dash`
+                i++
+            } else if (asymptote.type === ASYMPTOTE.HORIZONTAL) {
+                code += `\nah=line y=${asymptote.fx.monoms[0].coefficient.value}->orange,dash`
+            } else if (asymptote.type === ASYMPTOTE.SLOPE) {
+                code += `\nao=line y=${asymptote.fx.plotFunction}->red,dash`
+            }
+            i++
+        })
+
+        // Extremes
+        for (let zero in this.derivative.extremes) {
+            let extreme = this.derivative.extremes[zero]
+
+            code += `\nM_${i}(${extreme.value.x},${extreme.value.y})*`
+            i++
+        }
+
+        // Zeroes
+        this.zeroes.forEach(zero => {
+            if (zero.type === ZEROTYPE.ZERO) {
+                code += `\nZ_${i}(${zero.value},0)*`
+                i++
+            }
+        })
+
+        return code
+    }
 }

package/src/maths/coefficients/fraction.ts

@@ -1,14 +1,15 @@
 import {Numeric} from "../numeric";
 
-export type FractionParsingType = number|string|Fraction
+export type FractionParsingType = number | string | Fraction
+
 /**
  * The fraction class make possible to handle
  * TODO: Write the documentation correctly.
  * \\(\frac{a}{b}\\) or \\[\frac{a}{b}\\]  values.
  */
 export class Fraction {
-    private _numerator: number;
     private _denominator: number;
+    private _numerator: number;
 
     constructor(value?: unknown, denominatorOrPeriodic?: number) {
         this._numerator = 1;
@@ -47,24 +48,32 @@ export class Fraction {
 
     // Display getter
     get tex(): string {
-        if(this.isInfinity()){
-            return `${this.sign()===1?'+':'-'}\\infty`
+        if (this.isInfinity()) {
+            return `${this.sign() === 1 ? '+' : '-'}\\infty`
         }
 
-        if (this._denominator === 1) {
-            return `${this._numerator}`;
-        } else if (this._numerator < 0) {
-            return `-\\frac{ ${-this._numerator} }{ ${this._denominator} }`;
+        if (this.isExact()) {
+            if (this._denominator === 1) {
+                return `${this._numerator}`;
+            } else if (this._numerator < 0) {
+                return `-\\frac{ ${-this._numerator} }{ ${this._denominator} }`;
+            } else {
+                return `\\frac{ ${this._numerator} }{ ${this._denominator} }`;
+            }
         } else {
-            return `\\frac{ ${this._numerator} }{ ${this._denominator} }`;
+            return this.value.toFixed(3)
         }
     }
 
     get display(): string {
-        if (this._denominator === 1) {
-            return `${this._numerator}`;
+        if (this.isExact()) {
+            if (this._denominator === 1) {
+                return `${this._numerator}`;
+            } else {
+                return `${this._numerator}/${this._denominator}`;
+            }
         } else {
-            return `${this._numerator}/${this._denominator}`;
+            return this.value.toFixed(3)
         }
     }
 
@@ -76,12 +85,89 @@ export class Fraction {
     get dfrac(): string {
         return this.tex.replace('\\frac', '\\dfrac');
     }
+
     get tfrac(): string {
         return this.tex.replace('\\frac', '\\tfrac')
     }
 
+    static max = (...fractions: (Fraction | number)[]): Fraction => {
+        let M = new Fraction(fractions[0])
+
+        for (let m of fractions) {
+            let compare = new Fraction(m)
+            if (compare.greater(M)) {
+                M = compare.clone()
+            }
+        }
+
+        return M
+    }
+
+    static min = (...fractions: (Fraction | number)[]): Fraction => {
+        let M = new Fraction(fractions[0])
+
+        for (let m of fractions) {
+            let compare = new Fraction(m)
+            if (compare.lesser(M)) {
+                M = compare.clone()
+            }
+        }
+
+        return M
+    }
+
     // ------------------------------------------
     // Creation / parsing functions
+
+    static average = (...fractions: (Fraction | number)[]): Fraction => {
+        let M = new Fraction().zero()
+
+        for (let f of fractions) {
+            M.add(f)
+        }
+
+        M.divide(fractions.length)
+
+        return M
+    }
+
+    static unique = (fractions: Fraction[], sorted?: boolean): Fraction[] => {
+        // TODO: make sure it's wokring -> test !
+        let unique: { [Key: string]: boolean } = {},
+            distinct: Fraction[] = []
+        fractions.forEach(x => {
+            if (!unique[x.clone().reduce().tex]) {
+                distinct.push(x.clone())
+                unique[x.tex] = true
+            }
+        })
+
+        if (sorted) {
+            return Fraction.sort(distinct)
+        } else {
+            return distinct
+        }
+    }
+
+    static sort = (fractions: Fraction[], reverse?: boolean): Fraction[] => {
+        // Todo make sure it's the correct order, not reverse -> make a test
+        let sorted = fractions.sort((a, b) => a.value - b.value)
+
+        if (reverse) {
+            sorted.reverse()
+        }
+
+        return sorted
+    }
+
+    isApproximative = (): boolean => {
+        return this._numerator.toString().length >= 15 && this._denominator.toString().length >= 15
+    }
+
+    isExact = (): boolean => {
+        return !this.isApproximative()
+    }
+
     // ------------------------------------------
     /**
      * Parse the value to get the numerator and denominator
@@ -100,16 +186,15 @@ export class Fraction {
 
         switch (typeof value) {
             case "string":
-                // Split the sting value in two parts: Numerator/Denominator
+                // Split the string value in two parts: Numerator/Denominator
                 S = value.split('/');
 
                 // Security checks
-                if (S.length > 2) throw "Two many divide signs";
-                if (S.map(x => x === '' || isNaN(Number(x))).includes(true)) throw "Not a number"
-
+                if (S.length > 2) throw value + " has too many divide signs";
+                if (S.map(x => x === '' || isNaN(Number(x))).includes(true)) throw value + " is not a valid number"
 
                 if (S.length === 1) {
-                    // No divide sign
+                    // No divide sign - it's a number
                     return this.parse(+S[0]);
                 } else if (S.length === 2) {
                     // One divide signe
@@ -123,6 +208,7 @@ export class Fraction {
                     }
                 } else {
                     // More than one divide sign ?
+                    // This is impossible
                     this._numerator = NaN;
                     this._denominator = 1;
                 }
@@ -164,6 +250,9 @@ export class Fraction {
         return this;
     };
 
+    // ------------------------------------------
+    // Mathematical operations
+
     clone = (): Fraction => {
         let F = new Fraction();
         F.numerator = +this._numerator;
@@ -195,8 +284,6 @@ export class Fraction {
         return this;
     };
 
-    // ------------------------------------------
-    // Mathematical operations
     // ------------------------------------------
     opposed = (): Fraction => {
         this._numerator = -this._numerator;
@@ -259,6 +346,7 @@ export class Fraction {
 
         return this;
     }
+
     pow = (p: number | Fraction): Fraction => {
         // TODO: Fraction.pow with a value different than a safe integer !
         if (p instanceof Fraction) {
@@ -275,13 +363,13 @@ export class Fraction {
         let controlNumerator = Math.floor(Math.pow(this._numerator, Math.abs(p))),
             controlDenominator = Math.floor(Math.pow(this._denominator, Math.abs(p)))
 
-        if(controlNumerator ** Math.abs(p) === this._numerator
+        if (controlNumerator ** Math.abs(p) === this._numerator
             &&
-            controlDenominator ** Math.abs(p) === this._denominator){
+            controlDenominator ** Math.abs(p) === this._denominator) {
 
             this._numerator = this._numerator ** Math.abs(p);
             this._denominator = this._denominator ** Math.abs(p);
-        }else{
+        } else {
             this._numerator = this._numerator ** Math.abs(p);
             this._denominator = this._denominator ** Math.abs(p);
         }
@@ -320,72 +408,9 @@ export class Fraction {
         return this;
     };
 
-
-    static max = (...fractions: (Fraction | number)[]): Fraction => {
-        let M = new Fraction(fractions[0])
-
-        for (let m of fractions) {
-            let compare = new Fraction(m)
-            if (compare.greater(M)) {
-                M = compare.clone()
-            }
-        }
-
-        return M
-    }
-    static min = (...fractions: (Fraction | number)[]): Fraction => {
-        let M = new Fraction(fractions[0])
-
-        for (let m of fractions) {
-            let compare = new Fraction(m)
-            if (compare.lesser(M)) {
-                M = compare.clone()
-            }
-        }
-
-        return M
-    }
-
-    static average = (...fractions: (Fraction|number)[]): Fraction => {
-        let M = new Fraction().zero()
-
-        for(let f of fractions){
-            M.add(f)
-        }
-
-        M.divide(fractions.length)
-
-        return M
-    }
-
-    static unique = (fractions: Fraction[], sorted?: boolean): Fraction[] => {
-        // TODO: make sure it's wokring -> test !
-        let unique:{[Key:string]:boolean} = {},
-            distinct: Fraction[] = []
-        fractions.forEach(x => {
-            if(!unique[x.clone().reduce().tex]){
-                distinct.push(x.clone())
-                unique[x.tex]=true
-            }
-        })
-
-        if(sorted) {
-            return Fraction.sort(distinct)
-        }else{
-            return distinct
-        }
-    }
-    static sort = (fractions: Fraction[], reverse?:boolean): Fraction[] => {
-        // Todo make sure it's the correct order, not reverse -> make a test
-        let sorted = fractions.sort((a, b)=>a.value-b.value)
-
-        if(reverse){sorted.reverse()}
-
-        return sorted
-    }
-
     // ------------------------------------------
     // Mathematical operations specific to fractions
+
     // ------------------------------------------
     reduce = (): Fraction => {
         let g = Numeric.gcd(this._numerator, this._denominator);