pimath 0.0.128 → 0.0.130

package/{src → lib}/maths/algebra/equation.ts

@@ -1,6 +1,6 @@
 import {Polynom} from "./polynom";
 import {literalType, Monom} from "./monom";
-import {Numeric} from "../numeric";
+import {Numeric} from "../numeric.ts";
 import {Fraction} from "../coefficients/fraction";
 import {NthRoot} from "../coefficients/nthRoot";
 
@@ -15,8 +15,8 @@ export interface ISolution {
 }
 
 export enum PARTICULAR_SOLUTION {
-    real="\\mathbb{R}",
-    varnothing="\\varnothing"
+    real = "\\mathbb{R}",
+    varnothing = "\\varnothing"
 }
 
 export class Equation {
@@ -25,6 +25,14 @@ export class Equation {
     // Undetermined texSolutions.
     private _varnothing: string = PARTICULAR_SOLUTION.varnothing;
     private _real: string = PARTICULAR_SOLUTION.real;
+    private _left: Polynom;  // Left part of the equation
+    private _right: Polynom; // Right part of the equation
+    private _sign: string;   // Signe of the equation, by default =
+    private _solutions: ISolution[]
+    // -----------------------------------------------
+    private _randomizeDefaults: { [key: string]: number | string | boolean } = {
+        degree: 2
+    };
 
     /**
      * Create an Equation using two polynoms.
@@ -63,7 +71,8 @@ export class Equation {
         return this;
     }
 
-    private _left: Polynom;  // Left part of the equation
+    // ------------------------------------------
+    // Getter and setter
 
     get left(): Polynom {
         return this._left;
@@ -73,21 +82,14 @@ export class Equation {
         this._left = value;
     }
 
-    private _right: Polynom; // Right part of the equation
-
     get right(): Polynom {
         return this._right;
     }
 
-    // ------------------------------------------
-    // Getter and setter
-
     set right(value: Polynom) {
         this._right = value;
     }
 
-    private _sign: string;   // Signe of the equation, by default =
-
     get sign(): string {
         return this._sign;
     }
@@ -97,8 +99,6 @@ export class Equation {
         this._sign = this._formatSign(value);
     }
 
-    private _solutions: ISolution[]
-
     // ------------------------------------------
     get solutions(): ISolution[] {
         return this._solutions
@@ -166,18 +166,9 @@ export class Equation {
         return this.variables.length;
     }
 
-    hasVariable = (letter: string): boolean => {
-        return this.variables.includes(letter)
-    }
-
     // ------------------------------------------
     // Creation / parsing functions
 
-    // -----------------------------------------------
-    private _randomizeDefaults: { [key: string]: number | string | boolean } = {
-        degree: 2
-    };
-
     get randomizeDefaults(): { [key: string]: number | string | boolean } {
         return this._randomizeDefaults;
     }
@@ -186,6 +177,27 @@ export class Equation {
         this._randomizeDefaults = value;
     }
 
+    static makeSolutionsUnique(solutions: ISolution[], sorted?: boolean): ISolution[] {
+        let solutionAsTex: string[] = [],
+            uniqueSolutions = solutions.filter(sol => {
+                if (!solutionAsTex.includes(sol.tex)) {
+                    solutionAsTex.push(sol.tex)
+                    return true
+                } else {
+                    return false
+                }
+            })
+
+        if (sorted === true) {
+            uniqueSolutions.sort((a, b) => a.value - b.value)
+        }
+        return uniqueSolutions
+    }
+
+    hasVariable = (letter: string): boolean => {
+        return this.variables.includes(letter)
+    }
+
     // ------------------------------------------
     parse = (equationString: string): Equation => {
         let pStr: string[], strSign: string | false;
@@ -210,13 +222,13 @@ export class Equation {
         return this;
     };
 
+    // -----------------------------------------------
+    // Equations generators and randomizers
+
     clone = (): Equation => {
         return new Equation().create(this._left.clone(), this._right.clone(), this._sign + '');
     };
 
-    // -----------------------------------------------
-    // Equations generators and randomizers
-
     randomize = (opts?: {}, sign?: string): Equation => {
         // TODO: Generate equations randomly, using config.
         return new Equation().create(new Polynom(), new Polynom(), sign);
@@ -244,8 +256,8 @@ export class Equation {
 
         // Fetch all zero degree monoms.
         this._left.monoms
-            .filter(m=>m.degree().isZero())
-            .forEach(m=> {
+            .filter(m => m.degree().isZero())
+            .forEach(m => {
                 const move = m.clone()
                 this._left.subtract(move)
                 this._right.subtract(move)
@@ -258,6 +270,10 @@ export class Equation {
         return this;
     };
 
+
+    // -----------------------------------------------
+    // Equations operations
+
     /**
      * Multiply by the lcm denominator and divide by the gcm numerators.
      */
@@ -267,10 +283,6 @@ export class Equation {
         return this;
     }
 
-
-    // -----------------------------------------------
-    // Equations operations
-
     /**
      * Reorder the polynom to have only one letter on the left, the rest on the right.
      * @param letter
@@ -381,15 +393,15 @@ export class Equation {
         return this._left.isMultiVariable || this._right.isMultiVariable;
     };
 
+    // -----------------------------------------------
+    // Equations helpers
+    // -----------------------------------------------
+
     letters = (): string[] => {
         // @ts-ignore
         return [...new Set([...this._left.letters(), ...this._right.letters()])];
     }
 
-    // -----------------------------------------------
-    // Equations helpers
-    // -----------------------------------------------
-
     // -----------------------------------------------
     solve = (): Equation => {
         // Initialise the variables:
@@ -416,23 +428,6 @@ export class Equation {
         return this;
     };
 
-    static makeSolutionsUnique(solutions: ISolution[], sorted?: boolean):ISolution[] {
-        let solutionAsTex:string[] = [],
-            uniqueSolutions = solutions.filter(sol=>{
-                if(!solutionAsTex.includes(sol.tex)){
-                    solutionAsTex.push(sol.tex)
-                    return true
-                }else{
-                    return false
-                }
-            })
-
-        if(sorted===true){
-            uniqueSolutions.sort((a, b)=>a.value-b.value)
-        }
-        return uniqueSolutions
-    }
-
     test = (values: literalType): Boolean => {
         return this.left.evaluate(values).isEqual(this.right.evaluate(values))
     }
@@ -583,8 +578,7 @@ export class Equation {
                     exact: v
                 }]
             }
-        }
-        else {
+        } else {
             if (m1.value === 0) {
                 // In this case, the coefficient of the x variable is zero.
                 if (m0.value === 0 && this.isAlsoEqual()) {
@@ -664,7 +658,7 @@ export class Equation {
                     // -------------------------
                     //           2a
                     let gcd = Numeric.gcd(b, 2 * a, nthDelta.coefficient),
-                        am = a/gcd, bm = b/gcd
+                        am = a / gcd, bm = b / gcd
                     nthDelta.coefficient = nthDelta.coefficient / gcd;
 
                     if (a < 0) {
@@ -878,14 +872,14 @@ export class Equation {
 
         this._solutions = []
 
-        equ.left.factors.forEach(factor=>{
-            if(factor.degree(letter).leq(2)) {
+        equ.left.factors.forEach(factor => {
+            if (factor.degree(letter).leq(2)) {
                 let factorAsEquation = new Equation(factor, 0)
                 factorAsEquation.solve()
                 factorAsEquation.solutions.forEach(solution => {
                     this._solutions.push(solution)
                 })
-            }else{
+            } else {
                 console.log(factor.tex, ': cannot actually get the solution of this equation')
             }
         })

package/{src → lib}/maths/algebra/linearSystem.ts

@@ -2,7 +2,7 @@ import {Equation, ISolution} from "./equation";
 import {Monom} from "./monom";
 import {Fraction} from "../coefficients/fraction";
 import {Polynom} from "./polynom";
-import {Numeric} from "../numeric";
+import {Numeric} from "../numeric.ts";
 
 // TODO: Must check and rework
 export class LinearSystem {
@@ -121,6 +121,10 @@ export class LinearSystem {
         return `(${display.join(';')})`;
     }
 
+    get resolutionSteps(): { [p: string]: { equations: Equation[]; operations: string[][] }[] } {
+        return this._resolutionSteps;
+    }
+
     buildTex = (equations: Equation[], operators?: (string[])[]): string => {
         let equStr: string[],
             equArray: string[] = [],
@@ -191,11 +195,6 @@ export class LinearSystem {
 
     }
 
-
-    get resolutionSteps(): { [p: string]: { equations: Equation[]; operations: string[][] }[] } {
-        return this._resolutionSteps;
-    }
-
 // ------------------------------------------
     // Creation / parsing functions
 

package/lib/maths/algebra/logicalset.ts

@@ -0,0 +1,183 @@
+/**
+ * Polynom module contains everything necessary to handle polynoms.
+ * @module Logicalset
+ */
+
+import {Shutingyard, ShutingyardMode} from '../shutingyard.ts';
+
+/**
+ * Polynom class can handle polynoms, reorder, resolve, ...
+ */
+export class Logicalset {
+    private _rawString: string;
+    private _rpn: { token: string, tokenType: string }[]
+
+    /**
+     *
+     * @param {string} value (optional) Default polynom to parse on class creation
+     */
+    constructor(value: string) {
+        this._rawString = value
+        this.parse(value)
+        return this;
+    }
+
+    get isLogicalset() {
+        return true;
+    };
+
+    get rpn(): { token: string, tokenType: string }[] {
+        return this._rpn
+    }
+
+    get tex(): string {
+        let varStack: { token: string, tokenType: string } [] = []
+
+        for (let token of this._rpn) {
+            if (token.tokenType === 'variable') {
+                varStack.push(token);
+            } else {
+                switch (token.token) {
+                    case '&':
+                        if (varStack.length >= 2) {
+                            let second = varStack.pop(),
+                                first = varStack.pop()
+
+                            if (first.tokenType === 'mix') {
+                                first.token = `( ${first.token} )`
+                            }
+                            if (second.tokenType === 'mix') {
+                                second.token = `( ${second.token} )`
+                            }
+                            varStack.push({token: `${first.token} \\cap ${second.token}`, tokenType: 'mix'})
+                        }
+                        break
+                    case '|':
+                        if (varStack.length >= 2) {
+                            let second = varStack.pop(),
+                                first = varStack.pop()
+
+                            if (first.tokenType === 'mix') {
+                                first.token = `( ${first.token} )`
+                            }
+                            if (second.tokenType === 'mix') {
+                                second.token = `( ${second.token} )`
+                            }
+                            varStack.push({token: `${first.token} \\cup ${second.token}`, tokenType: 'mix'})
+                        }
+                        break
+                    case '-':
+                        if (varStack.length >= 2) {
+                            let second = varStack.pop(),
+                                first = varStack.pop()
+
+                            if (first.tokenType === 'mix') {
+                                first.token = `( ${first.token} )`
+                            }
+                            if (second.tokenType === 'mix') {
+                                second.token = `( ${second.token} )`
+                            }
+                            varStack.push({token: `${first.token} \\setminus ${second.token}`, tokenType: 'mix'})
+                        }
+                        break
+                    case '!':
+                        if (varStack.length >= 1) {
+                            let first = varStack.pop()
+                            varStack.push({token: `\\overline{ ${first.token} }`, tokenType: 'variable'})
+                        }
+                        break
+                }
+            }
+        }
+
+        return varStack[0].token
+    }
+
+    evaluate(tokenSets: { [key: string]: unknown[] }, reference?: unknown[]): unknown[] {
+        let varStack: (Set<unknown>)[] = []
+
+        let referenceSet: Set<unknown>
+        if (reference === undefined) {
+            referenceSet = new Set()
+            for (let key in tokenSets) {
+                referenceSet = new Set([...referenceSet, ...tokenSets[key]])
+            }
+        } else {
+            referenceSet = new Set(reference)
+        }
+
+        for (let token of this._rpn) {
+            if (token.tokenType === 'variable') {
+                // The variable has no token - assume it's empty.
+                if (tokenSets[token.token] === undefined) {
+                    varStack.push(new Set())
+                } else {
+                    varStack.push(new Set(tokenSets[token.token]));
+                }
+
+            } else {
+                switch (token.token) {
+                    case '&':
+                        if (varStack.length >= 2) {
+                            let second = varStack.pop(),
+                                first = varStack.pop()
+
+                            varStack.push(new Set([...first].filter(x => second.has(x))))
+                        }
+                        break
+                    case '|':
+                        if (varStack.length >= 2) {
+                            let second = varStack.pop(),
+                                first = varStack.pop()
+                            varStack.push(new Set([...first, ...second]))
+                        }
+                        break
+                    case '-':
+                        if (varStack.length >= 2) {
+                            let second = varStack.pop(),
+                                first = varStack.pop()
+                            varStack.push(new Set([...first].filter(x => !second.has(x))))
+                        }
+                        break
+                    case '!':
+                        if (varStack.length >= 1) {
+                            let first = varStack.pop()
+
+                            varStack.push(new Set([...referenceSet].filter(x => !first.has(x))))
+                        }
+                        break
+                }
+            }
+        }
+
+        return [...varStack[0]].sort();
+    }
+
+    vennAB(): any[] {
+        return this.evaluate({
+                A: ['A', 'AB'],
+                B: ['B', 'AB']
+            },
+            ['A', 'B', 'AB', 'E']
+        )
+    }
+
+    vennABC(): any[] {
+        return this.evaluate({
+                A: ['A', 'AB', 'AC', 'ABC'],
+                B: ['B', 'AB', 'BC', 'ABC'],
+                C: ['C', 'AC', 'BC', 'ABC']
+            },
+            ['A', 'B', 'C', 'AB', 'AC', 'BC', 'E']
+        )
+    }
+
+    private parse = (value: string): Logicalset => {
+        // TODO: Must format the value string to convert some items...
+
+        // Parse the updated value to the shutingyard algorithm
+        this._rpn = new Shutingyard(ShutingyardMode.SET).parse(value).rpn;
+
+        return this;
+    }
+}

package/{src → lib}/maths/algebra/monom.ts

@@ -1,8 +1,8 @@
 /***
  * Monom class
  */
-import {Numeric} from "../numeric";
-import {Shutingyard, ShutingyardType, Token} from "../shutingyard";
+import {Numeric} from "../numeric.ts";
+import {Shutingyard, ShutingyardType, Token} from "../shutingyard.ts";
 import {Fraction} from "../coefficients/fraction";
 
 export type literalType = {
@@ -10,6 +10,9 @@ export type literalType = {
 }
 
 export class Monom {
+    private _coefficient: Fraction;
+    private _literal: literalType;
+
     /**
      * Create a Monom
      * Defined as \\(k \\cdot x^{n}\\), where \\( k,n \in \\mathbb{Q}\\).
@@ -27,7 +30,8 @@ export class Monom {
         return this;
     }
 
-    private _coefficient: Fraction;
+    // ------------------------------------------
+    // Getter and setter
 
     // ------------------------------------------
     /**
@@ -38,9 +42,6 @@ export class Monom {
         return this._coefficient;
     }
 
-    // ------------------------------------------
-    // Getter and setter
-
     /**
      * Set the coefficient \\(k\\) value of the monom
      * @param {Fraction | number | string} F
@@ -49,8 +50,6 @@ export class Monom {
         this._coefficient = new Fraction(F);
     }
 
-    private _literal: literalType;
-
     /**
      * Get the literal part of \\(x^{n_1}y^{n_2}\\) as dictionary \\[\\begin{array}{ll}x&=n_1\\\\y&=n_2\\end{array}\\]
      * @returns {literalType}

package/{src → lib}/maths/algebra/polynom.ts

@@ -3,8 +3,8 @@
  */
 
 import {literalType, Monom} from './monom';
-import {Shutingyard, ShutingyardType, Token} from '../shutingyard';
-import {Numeric} from '../numeric';
+import {Shutingyard, ShutingyardType, Token} from '../shutingyard.ts';
+import {Numeric} from '../numeric.ts';
 import {Fraction} from "../coefficients/fraction";
 import {Equation, ISolution} from "./equation";
 

package/{src → lib}/maths/algebra/study.ts

@@ -8,7 +8,7 @@ import {ISolution} from "./equation";
 import {Polynom} from "./polynom";
 import {Fraction} from "../coefficients/fraction";
 import {Point} from "../geometry/point";
-import {NumExp} from "../numexp";
+import {NumExp} from "../numexp.ts";
 
 export type StudyableFunction = Rational
 
@@ -125,22 +125,22 @@ export class Study {
         this.fx = fx
 
         this._config = {
-            name :'f',
+            name: 'f',
             variable: 'x',
-            domain :true,
-            asymptotes :true,
-            signs :true,
-            derivative :true,
-            variations :true,
+            domain: true,
+            asymptotes: true,
+            signs: true,
+            derivative: true,
+            variations: true,
         }
 
         if (config) {
             if (typeof config === 'string') {
                 const d = config.split(',')
                 this._config = {}
-                let n = d.filter(x=>x.includes('(') && x.includes(')'))
+                let n = d.filter(x => x.includes('(') && x.includes(')'))
 
-                if(n.length===1){
+                if (n.length === 1) {
                     this._config.name = n[0].split('(')[0]
                     this._config.variable = n[0].split('(')[1].split(')')[0]
                 }

package/{src → lib}/maths/coefficients/fraction.ts

@@ -1,4 +1,4 @@
-import {Numeric} from "../numeric";
+import {Numeric} from "../numeric.ts";
 
 export type FractionParsingType = number | string | Fraction
 
@@ -65,7 +65,7 @@ export class Fraction {
         }
     }
 
-    get texWithSign():string {
+    get texWithSign(): string {
         return this.isPositive() ? `+${this.tex}` : this.tex;
     }
 
@@ -231,7 +231,7 @@ export class Fraction {
                     // The given value is a float number
                     // Get the number of decimals after the float sign
                     let [unit, decimal] = (value.toString()).split('.')
-                    let p: number = decimal?decimal.length:0;
+                    let p: number = decimal ? decimal.length : 0;
 
                     // Detect if the decimal part is periodic or not...
 
@@ -336,7 +336,7 @@ export class Fraction {
         // Parse the value.
         // If it's a fraction, return a clone of it
         // If it's an integer, return the fraction F/1
-        for(let value of values){
+        for (let value of values) {
             let F = new Fraction(value)
             this._numerator = this._numerator * F.numerator;
             this._denominator = this._denominator * F.denominator;

package/{src → lib}/maths/geometry/circle.ts

@@ -2,13 +2,18 @@ import {Point} from "./point";
 import {Line, LinePropriety} from "./line";
 import {Vector} from "./vector";
 import {Triangle} from "./triangle";
-import {Numeric} from "../numeric";
+import {Numeric} from "../numeric.ts";
 import {Fraction} from "../coefficients/fraction";
 import {Equation} from "../algebra/equation";
 import {Polynom} from "../algebra/polynom";
 import {Monom} from "../algebra/monom";
 
 export class Circle {
+    private _center: Point;
+    private _squareRadius: Fraction;
+    private _cartesian: Equation;
+    private _exists: boolean;
+
     constructor(...values: unknown[]) {
         this._exists = false
 
@@ -17,26 +22,18 @@ export class Circle {
         }
     }
 
-    private _center: Point;
-
     get center(): Point {
         return this._center;
     }
 
-    private _squareRadius: Fraction;
-
     get squareRadius(): Fraction {
         return this._squareRadius
     }
 
-    private _cartesian: Equation;
-
     get cartesian(): Equation {
         return this._cartesian
     }
 
-    private _exists: boolean;
-
     get exists(): boolean {
         return this._exists;
     }

package/{src → lib}/maths/geometry/line.ts

@@ -4,7 +4,7 @@
 
 import {Vector} from "./vector";
 import {Point} from "./point";
-import {Numeric} from "../numeric";
+import {Numeric} from "../numeric.ts";
 import {Fraction} from "../coefficients/fraction";
 import {Equation} from "../algebra/equation";
 import {Polynom} from "../algebra/polynom";