pimath 0.0.128 → 0.0.130

package/dist/maths/randomization/rndGeometryLine.d.ts

@@ -0,0 +1,13 @@
+import { Line } from '../geometry/line';
+import { randomGeometryLineConfig } from './random';
+import { randomCore } from './randomCore';
+
+/**
+ * Create a random monom based on a based configuration
+ */
+export declare class rndGeometryLine extends randomCore {
+    protected _config: randomGeometryLineConfig;
+    protected _defaultConfig: randomGeometryLineConfig;
+    constructor(userConfig?: randomGeometryLineConfig);
+    generate: () => Line;
+}

package/dist/maths/randomization/rndGeometryPoint.d.ts

@@ -0,0 +1,13 @@
+import { Point } from '../geometry/point';
+import { randomGeometryPointConfig } from './random';
+import { randomCore } from './randomCore';
+
+/**
+ * Create a random monom based on a based configuration
+ */
+export declare class rndGeometryPoint extends randomCore {
+    protected _config: randomGeometryPointConfig;
+    protected _defaultConfig: randomGeometryPointConfig;
+    constructor(userConfig?: randomGeometryPointConfig);
+    generate: () => Point;
+}

package/dist/maths/randomization/rndHelpers.d.ts

@@ -0,0 +1,23 @@
+export declare class rndHelpers {
+    /**
+     * Random boolean with a percent ratio
+     * @param percent
+     */
+    static randomBool(percent?: number): boolean;
+    /**
+     * Random integer between two values.
+     * @param a (number) : From this value to the second value. If the second is ommited, this value is the max value.
+     * @param b (number) : To this value. If this is ommited.
+     */
+    static randomInt(a: number, b?: number, exclude?: number[]): number;
+    /**
+     * Random integer between -max and max value.
+     * @param max (number) : determine the limits.
+     * @param zero (bool) : determine if zero is allowed or not.
+     */
+    static randomIntSym(max: number, zero?: boolean): number;
+    static randomPrime(max: number): number;
+    static randomArray(arr: any[], number?: number): any[];
+    static randomItem(arr: any[]): any;
+    static shuffleArray(arr: any[]): any[];
+}

package/dist/maths/randomization/rndMonom.d.ts

@@ -0,0 +1,13 @@
+import { Monom } from '../algebra/monom';
+import { randomMonomConfig } from './rndTypes';
+import { randomCore } from './randomCore';
+
+/**
+ * Create a random monom based on a based configuration
+ */
+export declare class rndMonom extends randomCore {
+    protected _config: randomMonomConfig;
+    protected _defaultConfig: randomMonomConfig;
+    generate: () => Monom;
+    constructor(userConfig?: randomMonomConfig);
+}

package/dist/maths/randomization/rndPolynom.d.ts

@@ -0,0 +1,14 @@
+import { Polynom } from '../algebra/polynom';
+import { randomPolynomConfig } from './rndTypes';
+import { randomCore } from './randomCore';
+
+/**
+ * Random polynoms
+ */
+export declare class rndPolynom extends randomCore {
+    protected _config: randomPolynomConfig;
+    protected _defaultConfig: randomPolynomConfig;
+    generate: () => Polynom;
+    constructor(userConfig?: randomPolynomConfig);
+    factorable: () => Polynom;
+}

package/dist/maths/randomization/rndTypes.d.ts

@@ -0,0 +1,40 @@
+import { Fraction } from '../coefficients/fraction';
+
+export type randomCoefficientConfig = {
+    negative?: boolean;
+    max?: number;
+    reduced?: boolean;
+    zero?: boolean;
+    natural?: boolean;
+};
+export type randomMonomConfig = {
+    letters?: string;
+    degree?: number;
+    fraction?: boolean | randomCoefficientConfig;
+    zero?: boolean;
+};
+export type randomPolynomConfig = randomMonomConfig & {
+    unit?: boolean;
+    factorable?: boolean;
+    allowNullMonom?: boolean;
+    numberOfMonoms?: number;
+    positive?: boolean;
+};
+export type randomGeometryLineConfig = {
+    A: {
+        x: number | Fraction;
+        y: number | Fraction;
+    };
+    slope?: Fraction | string | number;
+};
+export type randomGeometryPointConfig = {
+    quadrant?: number;
+    axis?: string | boolean;
+    fraction?: boolean;
+    max?: number;
+};
+export type randomGeometryCircleConfig = {
+    center?: randomGeometryPointConfig;
+    radius?: number;
+    pointsOnCircle?: number;
+};

package/dist/maths/shutingyard.d.ts

@@ -0,0 +1,59 @@
+export type tokenType = {
+    [key: string]: {
+        precedence: number;
+        associative: string;
+        type: string;
+    };
+};
+export declare const tokenConstant: {
+    [Key: string]: number;
+};
+export declare enum ShutingyardType {
+    VARIABLE = "variable",
+    COEFFICIENT = "coefficient",
+    OPERATION = "operation",
+    CONSTANT = "constant",
+    FUNCTION = "function",
+    MONOM = "monom"
+}
+export declare enum ShutingyardMode {
+    EXPRESSION = "expression",
+    POLYNOM = "polynom",
+    SET = "set",
+    NUMERIC = "numeric"
+}
+export type Token = {
+    token: string;
+    tokenType: string;
+};
+export declare class Shutingyard {
+    readonly _mode: ShutingyardMode;
+    private _rpn;
+    private _tokenConfig;
+    private _tokenConstant;
+    private _tokenKeys;
+    private _uniformize;
+    constructor(mode?: ShutingyardMode);
+    get rpn(): Token[];
+    get rpnToken(): string[];
+    /**
+     * Determin if the token is a defined operation
+     * Defined operations: + - * / ^ sin cos tan
+     * @param token
+     */
+    tokenConfigInitialization(): tokenType;
+    /**
+     * Get the next token to analyse.
+     * @param expr (string) Expression to analyse
+     * @param start (number) CUrrent position in the expr string.
+     */
+    NextToken(expr: string, start: number): [string, number, string];
+    normalize(expr: string): string;
+    /**
+     * Parse an expression using the shutting yard tree algorithms
+     * @param expr (string) Expression to analyse
+     * Returns a RPN list of items.
+     * @param uniformize
+     */
+    parse(expr: string, uniformize?: boolean): Shutingyard;
+}

package/dist/pimath.js

@@ -796,30 +796,6 @@ class K {
   get expression() {
     return this._expression;
   }
-  _extractDecimalPart(e) {
-    let t = e.toString();
-    return t.includes(".") ? (t = t.split(".")[1], t.substring(0, t.length - 2)) : "";
-  }
-  _numberCorrection(e) {
-    const s = this._extractDecimalPart(e);
-    if (s === "")
-      return e;
-    const n = s.match(/9+$/g), o = s.match(/0+$/g);
-    if (n && n[0].length >= 6) {
-      const l = this._extractDecimalPart(e + 1e-14), a = l.match(/0+$/g);
-      if (a && a[0].length >= 6)
-        return +(e + 1e-14).toString().split(a[0])[0];
-    }
-    if (o && o[0].length >= 6) {
-      const l = this._extractDecimalPart(e - 1e-14), a = l.match(/9+$/g);
-      if (a && a[0].length >= 6)
-        return +e.toString().split(o[0])[0];
-    }
-    return e;
-  }
-  _addToStack(e, t) {
-    e.push(this._numberCorrection(t));
-  }
   evaluate(e) {
     const t = [];
     if (this._rpn === null)
@@ -869,6 +845,30 @@ class K {
       return t[0];
     throw `There was a problem parsing: ${this._expression}`;
   }
+  _extractDecimalPart(e) {
+    let t = e.toString();
+    return t.includes(".") ? (t = t.split(".")[1], t.substring(0, t.length - 2)) : "";
+  }
+  _numberCorrection(e) {
+    const s = this._extractDecimalPart(e);
+    if (s === "")
+      return e;
+    const n = s.match(/9+$/g), o = s.match(/0+$/g);
+    if (n && n[0].length >= 6) {
+      const l = this._extractDecimalPart(e + 1e-14), a = l.match(/0+$/g);
+      if (a && a[0].length >= 6)
+        return +(e + 1e-14).toString().split(a[0])[0];
+    }
+    if (o && o[0].length >= 6) {
+      const l = this._extractDecimalPart(e - 1e-14), a = l.match(/9+$/g);
+      if (a && a[0].length >= 6)
+        return +e.toString().split(o[0])[0];
+    }
+    return e;
+  }
+  _addToStack(e, t) {
+    e.push(this._numberCorrection(t));
+  }
 }
 class D {
   constructor() {
@@ -1205,6 +1205,8 @@ const $ = class $ {
     return this.zero(), e !== void 0 && this.parse(e), this;
   }
   // ------------------------------------------
+  // Getter and setter
+  // ------------------------------------------
   /**
    * Get the coefficient \\(k\\) of the Monom \\(k\\cdot x^{n}\\)
    * @returns {Fraction}
@@ -1212,8 +1214,6 @@ const $ = class $ {
   get coefficient() {
     return this._coefficient;
   }
-  // ------------------------------------------
-  // Getter and setter
   /**
    * Set the coefficient \\(k\\) value of the monom
    * @param {Fraction | number | string} F
@@ -1496,16 +1496,17 @@ class k {
     r(this, "_varnothing", "\\varnothing");
     r(this, "_real", "\\mathbb{R}");
     r(this, "_left");
+    // Left part of the equation
     r(this, "_right");
+    // Right part of the equation
     r(this, "_sign");
+    // Signe of the equation, by default =
     r(this, "_solutions");
-    r(this, "hasVariable", (e) => this.variables.includes(e));
-    // ------------------------------------------
-    // Creation / parsing functions
     // -----------------------------------------------
     r(this, "_randomizeDefaults", {
       degree: 2
     });
+    r(this, "hasVariable", (e) => this.variables.includes(e));
     // ------------------------------------------
     r(this, "parse", (e) => {
       let t, i;
@@ -1516,9 +1517,9 @@ class k {
       return t = e.split(i), this.create(new u(t[0]), new u(t[1]), this._formatSign(i));
     });
     r(this, "create", (e, t, i) => (this._left = e, this._right = t, this._sign = this._formatSign(i), this));
-    r(this, "clone", () => new k().create(this._left.clone(), this._right.clone(), this._sign + ""));
     // -----------------------------------------------
     // Equations generators and randomizers
+    r(this, "clone", () => new k().create(this._left.clone(), this._right.clone(), this._sign + ""));
     r(this, "randomize", (e, t) => new k().create(new u(), new u(), t));
     // -----------------------------------------------
     /**
@@ -1529,12 +1530,12 @@ class k {
       const i = t.clone();
       this._left.subtract(i), this._right.subtract(i);
     }), this._left.reorder(), this._right.reorder(), this)));
+    // -----------------------------------------------
+    // Equations operations
     /**
      * Multiply by the lcm denominator and divide by the gcm numerators.
      */
     r(this, "simplify", () => (this.multiply(x.lcm(...this._left.getDenominators(), ...this._right.getDenominators())), this.divide(x.gcd(...this._left.getNumerators(), ...this._right.getNumerators())), this));
-    // -----------------------------------------------
-    // Equations operations
     /**
      * Reorder the polynom to have only one letter on the left, the rest on the right.
      * @param letter
@@ -1585,10 +1586,10 @@ class k {
      * Determine if the equation contains more than one letter/variable.
      */
     r(this, "isMultiVariable", () => this._left.isMultiVariable || this._right.isMultiVariable);
-    r(this, "letters", () => [.../* @__PURE__ */ new Set([...this._left.letters(), ...this._right.letters()])]);
     // -----------------------------------------------
     // Equations helpers
     // -----------------------------------------------
+    r(this, "letters", () => [.../* @__PURE__ */ new Set([...this._left.letters(), ...this._right.letters()])]);
     // -----------------------------------------------
     r(this, "solve", () => {
       switch (this._solutions = [], this._polynom = this._left.clone().subtract(this._right), this._polynom.degree().value) {
@@ -1781,23 +1782,20 @@ class k {
       return this;
     return this;
   }
-  // Left part of the equation
+  // ------------------------------------------
+  // Getter and setter
   get left() {
     return this._left;
   }
   set left(e) {
     this._left = e;
   }
-  // Right part of the equation
   get right() {
     return this._right;
   }
-  // ------------------------------------------
-  // Getter and setter
   set right(e) {
     this._right = e;
   }
-  // Signe of the equation, by default =
   get sign() {
     return this._sign;
   }
@@ -1838,6 +1836,8 @@ class k {
   get numberOfVars() {
     return this.variables.length;
   }
+  // ------------------------------------------
+  // Creation / parsing functions
   get randomizeDefaults() {
     return this._randomizeDefaults;
   }
@@ -2771,9 +2771,6 @@ const O = class O {
     r(this, "_x");
     // 1st component
     r(this, "_y");
-    // ------------------------------------------
-    // Creation / parsing functions
-    // ------------------------------------------
     r(this, "parse", (...e) => {
       if (this.zero(), e.length === 0)
         return this;
@@ -2791,14 +2788,10 @@ const O = class O {
       return this._x !== null && (e.x = this._x.clone()), this._y !== null && (e.y = this._y.clone()), e;
     });
     r(this, "reset", () => (this._x = null, this._y = null, this));
-    r(this, "zero", () => (this.reset(), this._x = new h(null), this._y = new h(null), this));
-    r(this, "one", () => (this._x = new h(), this._y = new h(), this));
-    r(this, "_parseString", (e) => {
-      let t = e.split(/[,;\s]/g);
-      return this.x = new h(t[0] || null), this.y = new h(t[1] || null), this;
-    });
     // ------------------------------------------
     // Mathematical operations
+    r(this, "zero", () => (this.reset(), this._x = new h(null), this._y = new h(null), this));
+    r(this, "one", () => (this._x = new h(), this._y = new h(), this));
     // ------------------------------------------
     r(this, "opposed", () => (this._x.opposed(), this._y.opposed(), this));
     r(this, "add", (e) => (this._x.add(e.x), this._y.add(e.y), this));
@@ -2816,10 +2809,10 @@ const O = class O {
       return this._x.multiply(t), this._y.multiply(t), this;
     });
     r(this, "divideByScalar", (e) => this.multiplyByScalar(new h(e).invert()));
+    r(this, "simplify", () => this.multiplyByScalar(x.lcm(this._x.denominator, this._y.denominator)).divideByScalar(x.gcd(this._x.numerator, this._y.numerator)));
     // ------------------------------------------
     // Vector functions
     // ------------------------------------------
-    r(this, "simplify", () => this.multiplyByScalar(x.lcm(this._x.denominator, this._y.denominator)).divideByScalar(x.gcd(this._x.numerator, this._y.numerator)));
     r(this, "simplifyDirection", () => {
       let e = x.lcm(this.x.denominator, this.y.denominator), t = x.gcd(this.x.numerator, this.y.numerator);
       return this.x.multiply(e).divide(t), this.y.multiply(e).divide(t), this;
@@ -2828,6 +2821,10 @@ const O = class O {
       let s = this.scalarProductWithVector(e).value, n = i ? 1 : 180 / Math.PI;
       return t && (s = Math.abs(s)), n * Math.acos(s / (this.norm * e.norm));
     });
+    r(this, "_parseString", (e) => {
+      let t = e.split(/[,;\s]/g);
+      return this.x = new h(t[0] || null), this.y = new h(t[1] || null), this;
+    });
     this._x = new h().zero(), this._y = new h().zero(), e !== void 0 && this.parse(...e);
   }
   // ------------------------------------------
@@ -2857,6 +2854,9 @@ const O = class O {
   get asPoint() {
     return new y(this.x, this.y);
   }
+  // ------------------------------------------
+  // Creation / parsing functions
+  // ------------------------------------------
   get isNull() {
     return this.x.isZero() && this.y.isZero();
   }
@@ -4159,6 +4159,43 @@ class fe {
   get isLogicalset() {
     return !0;
   }
+  get rpn() {
+    return this._rpn;
+  }
+  get tex() {
+    let e = [];
+    for (let t of this._rpn)
+      if (t.tokenType === "variable")
+        e.push(t);
+      else
+        switch (t.token) {
+          case "&":
+            if (e.length >= 2) {
+              let i = e.pop(), s = e.pop();
+              s.tokenType === "mix" && (s.token = `( ${s.token} )`), i.tokenType === "mix" && (i.token = `( ${i.token} )`), e.push({ token: `${s.token} \\cap ${i.token}`, tokenType: "mix" });
+            }
+            break;
+          case "|":
+            if (e.length >= 2) {
+              let i = e.pop(), s = e.pop();
+              s.tokenType === "mix" && (s.token = `( ${s.token} )`), i.tokenType === "mix" && (i.token = `( ${i.token} )`), e.push({ token: `${s.token} \\cup ${i.token}`, tokenType: "mix" });
+            }
+            break;
+          case "-":
+            if (e.length >= 2) {
+              let i = e.pop(), s = e.pop();
+              s.tokenType === "mix" && (s.token = `( ${s.token} )`), i.tokenType === "mix" && (i.token = `( ${i.token} )`), e.push({ token: `${s.token} \\setminus ${i.token}`, tokenType: "mix" });
+            }
+            break;
+          case "!":
+            if (e.length >= 1) {
+              let i = e.pop();
+              e.push({ token: `\\overline{ ${i.token} }`, tokenType: "variable" });
+            }
+            break;
+        }
+    return e[0].token;
+  }
   evaluate(e, t) {
     let i = [], s;
     if (t === void 0) {
@@ -4218,43 +4255,6 @@ class fe {
       ["A", "B", "C", "AB", "AC", "BC", "E"]
     );
   }
-  get rpn() {
-    return this._rpn;
-  }
-  get tex() {
-    let e = [];
-    for (let t of this._rpn)
-      if (t.tokenType === "variable")
-        e.push(t);
-      else
-        switch (t.token) {
-          case "&":
-            if (e.length >= 2) {
-              let i = e.pop(), s = e.pop();
-              s.tokenType === "mix" && (s.token = `( ${s.token} )`), i.tokenType === "mix" && (i.token = `( ${i.token} )`), e.push({ token: `${s.token} \\cap ${i.token}`, tokenType: "mix" });
-            }
-            break;
-          case "|":
-            if (e.length >= 2) {
-              let i = e.pop(), s = e.pop();
-              s.tokenType === "mix" && (s.token = `( ${s.token} )`), i.tokenType === "mix" && (i.token = `( ${i.token} )`), e.push({ token: `${s.token} \\cup ${i.token}`, tokenType: "mix" });
-            }
-            break;
-          case "-":
-            if (e.length >= 2) {
-              let i = e.pop(), s = e.pop();
-              s.tokenType === "mix" && (s.token = `( ${s.token} )`), i.tokenType === "mix" && (i.token = `( ${i.token} )`), e.push({ token: `${s.token} \\setminus ${i.token}`, tokenType: "mix" });
-            }
-            break;
-          case "!":
-            if (e.length >= 1) {
-              let i = e.pop();
-              e.push({ token: `\\overline{ ${i.token} }`, tokenType: "variable" });
-            }
-            break;
-        }
-    return e[0].token;
-  }
 }
 const de = {
   ShutingYard: P,

package/lib/main.ts

@@ -0,0 +1,42 @@
+import {Numeric} from "./maths/numeric.ts";
+import {NumExp} from "./maths/numexp.ts";
+import {Shutingyard} from "./maths/shutingyard.ts";
+import {Random} from "./maths/randomization/random.ts";
+import {Fraction} from "./maths/coefficients/fraction.ts";
+import {NthRoot} from "./maths/coefficients/nthRoot.ts";
+import {Monom} from "./maths/algebra/monom.ts";
+import {Polynom} from "./maths/algebra/polynom.ts";
+import {Equation} from "./maths/algebra/equation.ts";
+import {LinearSystem} from "./maths/algebra/linearSystem.ts";
+import {Rational} from "./maths/algebra/rational.ts";
+import {Logicalset} from "./maths/algebra/logicalset.ts";
+import {Vector} from "./maths/geometry/vector.ts";
+import {Line} from "./maths/geometry/line.ts";
+import {Triangle} from "./maths/geometry/triangle.ts";
+import {Circle} from "./maths/geometry/circle.ts";
+import {Point} from "./maths/geometry/point.ts";
+
+// Expose as global
+export const PiMath = {
+    ShutingYard: Shutingyard,
+    Numeric: Numeric,
+    NumExp: NumExp,
+    Fraction: Fraction,
+    Root: NthRoot,
+    Monom: Monom,
+    Polynom: Polynom,
+    Equation: Equation,
+    LinearSystem: LinearSystem,
+    Rational: Rational,
+    Logicalset: Logicalset,
+    Random: Random,
+    Geometry: {
+        Vector: Vector,
+        Point: Point,
+        Line: Line,
+        Triangle: Triangle,
+        Circle: Circle
+    }
+};
+
+// (<any>window).PiMath = PiMath