pimath 0.0.66 → 0.0.69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pimath",
-  "version": "0.0.66",
+  "version": "0.0.69",
   "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.ts

@@ -72,9 +72,9 @@ export interface ITableOfSigns {
 }
 
 export enum TABLE_OF_SIGNS {
-    DEFAULT,
-    GROWS,
-    VARIATIONS
+    SIGNS = "signs",
+    GROWS = "grows",
+    VARIATIONS = "variatins"
 }
 
 /**
@@ -323,7 +323,7 @@ export class Study {
 
     makeSigns(): ITableOfSigns {
         return {
-            type: TABLE_OF_SIGNS.DEFAULT,
+            type: TABLE_OF_SIGNS.SIGNS,
             fx: null,
             factors: [],
             zeroes: [],

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);

package/src/maths/expressions/expression.ts

@@ -0,0 +1,191 @@
+import {ExpressionFactor, ExpressionMember} from "./internals";
+
+export type ExpressionMemberType = { member: ExpressionMember, sign: number }
+
+export class Expression {
+    private _members: ExpressionMemberType[]
+
+    constructor(...values: (ExpressionMember | ExpressionFactor | ExpressionMemberType)[]) {
+        this._members = []
+        this.addMembers(...values)
+        return this
+    }
+
+    get tex(): string {
+        let tex:string = ""
+        for (let item of this._members) {
+
+            try {
+                if (tex === "") {
+                    tex = (item.sign === -1 ? "-" : "") + item.member.tex
+                } else {
+                    tex += (item.sign === -1 ? "-" : "+") + item.member.tex
+                }
+            }catch{
+                console.log('Error while generating the TeX code for ', item.constructor.name)
+            }
+        }
+        return tex
+    }
+
+    get members(): ExpressionMemberType[] {
+        return this._members;
+    }
+
+    set members(value: ExpressionMemberType[]) {
+        this._members = value;
+    }
+
+    addMembers(...values: (ExpressionMemberType | ExpressionMember | ExpressionFactor)[]): Expression {
+        for (let item of values) {
+            if (item instanceof ExpressionMember) {
+                this._members.push({
+                    member: item,
+                    sign: 1
+                })
+            }else if (item instanceof ExpressionFactor){
+                this._members.push({
+                    member: new ExpressionMember(item),
+                    sign: 1
+                })
+            }
+            else {
+                this._members.push(item)
+            }
+        }
+
+        return this
+    }
+
+    add(value: Expression | ExpressionMember | ExpressionFactor) {
+        if (value instanceof Expression) {
+            this.members = this.members.concat(...value.members)
+        } else if (value instanceof ExpressionMember) {
+            this.members.push({
+                    member: value,
+                    sign: 1
+                }
+            )
+        } else if (value instanceof ExpressionFactor) {
+            this.members.push({
+                member: new ExpressionMember(value),
+                sign: 1
+            })
+        }
+
+        return this
+    }
+
+    subtract(value: Expression | ExpressionMember | ExpressionFactor) {
+
+        if (value instanceof Expression) {
+            this.members = this.members.concat(
+                ...value.members
+                    .map(item => {
+                            return {member: item.member, sign: -item.sign}
+                        }
+                    )
+            )
+        } else if (value instanceof ExpressionMember) {
+            this.members.push({
+                    member: value,
+                    sign: -1
+                }
+            )
+        } else if (value instanceof ExpressionFactor) {
+            this.members.push({
+                member: new ExpressionMember(value),
+                sign: -1
+            })
+        }
+
+        return this
+    }
+
+
+    hasVariable(variable?: string): boolean {
+
+        if (variable === undefined) {
+            return !this.isNumeric()
+        }
+
+
+        for (let item of this._members) {
+            if (item.member.hasVariable(variable)) {
+                return true
+            }
+        }
+
+        // The variable hasn't been found !
+        return false
+    }
+
+    isZero(): boolean {
+        // TODO: Must check if all the members has a value of zero
+        if (this._members.length === 0) {
+            return true
+        }
+
+        for (let item of this._members) {
+            if (item.member.isZero()) {
+                return true
+            }
+        }
+
+        return false
+    }
+
+    isNumeric(): boolean {
+
+        for (let item of this._members) {
+            if (!item.member.isNumeric()) {
+                return false
+            }
+        }
+
+
+        return true;
+    }
+
+    isSingle(): Boolean {
+        if(this.members.length>1){
+            return false
+        }else if(this.members[0]?.member.factors.length>1){
+            return false
+        }else{
+            return true
+        }
+
+    }
+
+    isFactor(): Boolean {
+        return this.members.length===1
+    }
+
+
+    structure(depth?: number): string {
+        let struct: string[] = [],
+            indent = "",
+            dftIndent = "\t"
+
+        if(depth===undefined){depth = 0}
+        for(let i=0;i<depth; i++){
+            indent += dftIndent
+        }
+
+        struct.push(`${indent}${this.constructor.name}: ${this.tex}`)
+        for(let item of this._members){
+            struct.push(`${indent}${dftIndent}${item.member.constructor.name}: ${item.member.tex}`)
+            for(let factor of item.member.factors){
+                struct.push(`${indent}${dftIndent}${dftIndent}${factor.constructor.name}: ${factor.tex}`)
+                if(factor.argument!==null){
+                    struct.push(factor.argument.structure(depth+3))
+                }
+            }
+        }
+        return struct.join('\n')
+    }
+
+
+}
+

package/src/maths/expressions/expressionFactor.ts

@@ -0,0 +1,138 @@
+import {Expression} from "./internals";
+
+export abstract class ExpressionFactor {
+    constructor(
+        private _argument: Expression,
+        private _power?: number,
+        private _root?: number,
+        private _inline?: boolean
+    ) {
+        if (this._power === undefined) {
+            this._power = 1
+        }
+        if (this._root === undefined) {
+            this._root = 1
+        }
+        if (this._inline === undefined) {
+            this._inline = false
+        }
+    }
+
+    get inline(): boolean {
+        return this._inline;
+    }
+
+    set inline(value: boolean) {
+        this._inline = value;
+    }
+
+    get tex(): string {
+        return this.makeTeX()
+    }
+
+    get power(): number {
+        return this._power;
+    }
+
+    set power(value: number) {
+        if (!Number.isSafeInteger(value)) {
+            throw `Power value (${value}) is not a safe integer`
+        }
+        this._power = value;
+    }
+
+    get root(): number {
+        return this._root;
+    }
+
+    set root(value: number) {
+        if (!Number.isSafeInteger(value)) {
+            throw `Root value (${value}) is not a safe integer`
+        }
+        this._root = value;
+    }
+
+    get argument(): Expression {
+        return this._argument;
+    }
+
+    set argument(value: Expression) {
+        this._argument = value;
+    }
+
+    abstract makeTeX(numberOfFactors?: number, position?: number): string
+
+    abstract derivative(variable: string): Expression
+
+    abstract integrate(variable: string): Expression
+
+    hasVariable(variable?: string): boolean {
+
+        if (variable === undefined) {
+            return !this.isNumeric()
+        }
+
+        // The argument is an Expression
+        if (this._argument instanceof Expression) {
+            return this._argument.hasVariable(variable)
+        }
+
+        return false
+
+    }
+
+    isNumeric(): boolean {
+        if (this._argument instanceof Expression) {
+            return this.isNumeric()
+        }
+
+
+    }
+
+    hasRoot(): boolean {
+        return this.root > 1
+    }
+
+    hasPower(inline?: boolean): boolean {
+        if (inline === true) {
+            return !(this.power === 1)
+        } else {
+            return !(this.power === 1 || this.power === -1)
+        }
+    }
+
+
+    texPowerAndRoot(tex: string): string {
+        return this.texPower(this.texRoot(tex))
+    }
+
+    texPower(tex: string): string {
+        if (this.hasPower(this.inline)) {
+            return `${tex}^{ ${Math.abs(this.power)} }`
+        }
+
+        return tex
+    }
+
+    wrapWithParentheses(tex: string): string {
+        return `\\left( ${tex} \\right)`
+    }
+
+    texRoot(tex: string): string {
+        if (this.root === 2) {
+            return `\\sqrt{ ${tex} }`
+        } else if (this.root > 2) {
+            return `\\sqrt[${this.root}]{ ${tex} }`
+        }
+
+        return tex
+    }
+
+    isZero(): Boolean {
+        if (this._argument instanceof Expression) {
+            return this._argument.isZero()
+        }
+
+        return this._argument === 0
+    }
+}