pimath 0.0.127 → 0.0.129

package/dist/main.d.ts

@@ -0,0 +1,39 @@
+import { Point } from './maths/geometry/point.ts';
+import { Circle } from './maths/geometry/circle.ts';
+import { Triangle } from './maths/geometry/triangle.ts';
+import { Line } from './maths/geometry/line.ts';
+import { Vector } from './maths/geometry/vector.ts';
+import { Logicalset } from './maths/algebra/logicalset.ts';
+import { Rational } from './maths/algebra/rational.ts';
+import { LinearSystem } from './maths/algebra/linearSystem.ts';
+import { Equation } from './maths/algebra/equation.ts';
+import { Polynom } from './maths/algebra/polynom.ts';
+import { Monom } from './maths/algebra/monom.ts';
+import { NthRoot } from './maths/coefficients/nthRoot.ts';
+import { Fraction } from './maths/coefficients/fraction.ts';
+import { Random } from './maths/randomization/random.ts';
+import { Shutingyard } from './maths/shutingyard.ts';
+import { NumExp } from './maths/numexp.ts';
+import { Numeric } from './maths/numeric.ts';
+
+export declare const PiMath: {
+    ShutingYard: typeof Shutingyard;
+    Numeric: typeof Numeric;
+    NumExp: typeof NumExp;
+    Fraction: typeof Fraction;
+    Root: typeof NthRoot;
+    Monom: typeof Monom;
+    Polynom: typeof Polynom;
+    Equation: typeof Equation;
+    LinearSystem: typeof LinearSystem;
+    Rational: typeof Rational;
+    Logicalset: typeof Logicalset;
+    Random: typeof Random;
+    Geometry: {
+        Vector: typeof Vector;
+        Point: typeof Point;
+        Line: typeof Line;
+        Triangle: typeof Triangle;
+        Circle: typeof Circle;
+    };
+};

package/{esm → dist}/maths/algebra/equation.d.ts

@@ -1,6 +1,7 @@
-import { Polynom } from "./polynom";
-import { literalType } from "./monom";
-import { Fraction } from "../coefficients/fraction";
+import { Fraction } from '../coefficients/fraction';
+import { literalType } from './monom';
+import { Polynom } from './polynom';
+
 /**
  * Equation is a class to manage equations...
  */
@@ -18,22 +19,23 @@ export declare class Equation {
     private _polynom;
     private _varnothing;
     private _real;
+    private _left;
+    private _right;
+    private _sign;
+    private _solutions;
+    private _randomizeDefaults;
     /**
      * Create an Equation using two polynoms.
      * Markdown *support* is cool
      * @param equations
      */
     constructor(...equations: unknown[]);
-    private _left;
     get left(): Polynom;
     set left(value: Polynom);
-    private _right;
     get right(): Polynom;
     set right(value: Polynom);
-    private _sign;
     get sign(): string;
     set sign(value: string);
-    private _solutions;
     get solutions(): ISolution[];
     get isEquation(): boolean;
     get solution(): string;
@@ -45,14 +47,14 @@ export declare class Equation {
     get raw(): string;
     get variables(): string[];
     get numberOfVars(): number;
-    hasVariable: (letter: string) => boolean;
-    private _randomizeDefaults;
     get randomizeDefaults(): {
         [key: string]: number | string | boolean;
     };
     set randomizeDefaults(value: {
         [key: string]: number | string | boolean;
     });
+    static makeSolutionsUnique(solutions: ISolution[], sorted?: boolean): ISolution[];
+    hasVariable: (letter: string) => boolean;
     parse: (equationString: string) => Equation;
     create: (left: Polynom, right: Polynom, sign?: string) => Equation;
     clone: () => Equation;
@@ -103,7 +105,6 @@ export declare class Equation {
     isMultiVariable: () => boolean;
     letters: () => string[];
     solve: () => Equation;
-    static makeSolutionsUnique(solutions: ISolution[], sorted?: boolean): ISolution[];
     test: (values: literalType) => Boolean;
     isSameAs: (equ: Equation) => Boolean;
     isLinearTo: (equ: Equation) => Boolean;

package/{esm → dist}/maths/algebra/linearSystem.d.ts

@@ -1,5 +1,6 @@
-import { Equation } from "./equation";
-import { Fraction } from "../coefficients/fraction";
+import { Fraction } from '../coefficients/fraction';
+import { Equation } from './equation';
+
 export declare class LinearSystem {
     private _equations;
     private _letters;
@@ -15,14 +16,14 @@ export declare class LinearSystem {
     get tex(): string;
     get solution(): string;
     get solutionAsDisplay(): string;
-    buildTex: (equations: Equation[], operators?: (string[])[]) => string;
-    stepTex: (letter: string) => string;
     get resolutionSteps(): {
         [p: string]: {
             equations: Equation[];
             operations: string[][];
         }[];
     };
+    buildTex: (equations: Equation[], operators?: (string[])[]) => string;
+    stepTex: (letter: string) => string;
     parse: (...equations: (string | Equation)[]) => LinearSystem;
     clone: () => LinearSystem;
     reorder: () => LinearSystem;

package/{esm → dist}/maths/algebra/monom.d.ts

@@ -1,9 +1,12 @@
-import { Token } from "../shutingyard";
-import { Fraction } from "../coefficients/fraction";
+import { Fraction } from '../coefficients/fraction';
+import { Token } from '../shutingyard.ts';
+
 export type literalType = {
     [Key: string]: Fraction;
 };
 export declare class Monom {
+    private _coefficient;
+    private _literal;
     /**
      * Create a Monom
      * Defined as \\(k \\cdot x^{n}\\), where \\( k,n \in \\mathbb{Q}\\).
@@ -11,7 +14,6 @@ export declare class Monom {
      * @param value (optional) string The value that should be parse. Can be a Monom, a Fraction, a string or a number. If nothing is provided, it will return the trivial monom (0).
      */
     constructor(value?: unknown);
-    private _coefficient;
     /**
      * Get the coefficient \\(k\\) of the Monom \\(k\\cdot x^{n}\\)
      * @returns {Fraction}
@@ -22,7 +24,6 @@ export declare class Monom {
      * @param {Fraction | number | string} F
      */
     set coefficient(F: Fraction | number | string);
-    private _literal;
     /**
      * 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/{esm → dist}/maths/algebra/polynom.d.ts

@@ -1,10 +1,8 @@
-/**
- * Polynom module contains everything necessary to handle polynoms.*
- */
+import { ISolution } from './equation';
+import { Fraction } from '../coefficients/fraction';
+import { Token } from '../shutingyard.ts';
 import { literalType, Monom } from './monom';
-import { Token } from '../shutingyard';
-import { Fraction } from "../coefficients/fraction";
-import { ISolution } from "./equation";
+
 export type PolynomParsingType = string | Polynom | number | Fraction | Monom;
 export interface IEuclidian {
     quotient: Polynom;
@@ -18,34 +16,34 @@ export interface IEuclidian {
  */
 export declare class Polynom {
     private _rawString;
+    private _dirty_factors;
+    private _dirty_zeroes;
+    private _euclidianCache;
+    private _factors;
+    private _monoms;
+    private _texString;
+    private _zeroes;
     /**
      *
      * @param {string} polynomString (optional) Default polynom to parse on class creation
      * @param values
      */
     constructor(polynomString?: PolynomParsingType, ...values: unknown[]);
-    private _dirty_factors;
     get dirty_factors(): boolean;
     set dirty_factors(value: boolean);
-    private _dirty_zeroes;
     get dirty_zeroes(): boolean;
     set dirty_zeroes(value: boolean);
-    private _euclidianCache;
     get euclidianCache(): {
         [p: string]: IEuclidian;
     };
     set euclidianCache(value: {
         [p: string]: IEuclidian;
     });
-    private _factors;
     get factors(): Polynom[];
     set factors(value: Polynom[]);
-    private _monoms;
     get monoms(): Monom[];
     set monoms(M: Monom[]);
-    private _texString;
     get texString(): string;
-    private _zeroes;
     get zeroes(): ISolution[];
     get texFactors(): string;
     get displayFactors(): string;

package/{esm → dist}/maths/algebra/rational.d.ts

@@ -1,12 +1,9 @@
-/**
- * Rational polynom module contains everything necessary to handle rational polynoms.
- * @module Polynom
- */
-import { IEuclidian, Polynom } from "./polynom";
-import { Fraction } from "../coefficients/fraction";
-import { literalType } from "./monom";
-import { RationalStudy } from "./study/rationalStudy";
-import { StudyConfig } from "./study";
+import { StudyConfig } from './study';
+import { RationalStudy } from './study/rationalStudy';
+import { literalType } from './monom';
+import { Fraction } from '../coefficients/fraction';
+import { IEuclidian, Polynom } from './polynom';
+
 /**
  * Rational class can handle rational polynoms
  */
@@ -25,6 +22,7 @@ export declare class Rational {
     get tex(): string;
     get display(): string;
     get texFactors(): string;
+    get displayFactors(): string;
     get plotFunction(): string;
     clone: () => Rational;
     domain: () => string;

package/dist/maths/algebra/study/rationalStudy.d.ts

@@ -0,0 +1,14 @@
+import { Rational } from '../rational';
+import { ASYMPTOTE_POSITION, IAsymptote, ITableOfSigns, IZero, Study, StudyableFunction, StudyConfig } from '../study';
+
+export declare class RationalStudy extends Study {
+    constructor(fx: StudyableFunction, config?: StudyConfig | string);
+    makeZeroes(): IZero[];
+    makeSigns(): ITableOfSigns;
+    makeAsymptotes(): IAsymptote[];
+    _getHorizontalAsymptoteRelativePositon(deltaX: Rational, delta?: number): ASYMPTOTE_POSITION[];
+    makeDerivative(): ITableOfSigns;
+    makeVariation(): ITableOfSigns;
+    private _getZeroes;
+    private _getSigns;
+}

package/{esm → dist}/maths/algebra/study.d.ts

@@ -1,10 +1,7 @@
-/**
- * Rational polynom module contains everything necessary to handle rational polynoms.
- * @module Polynom
- */
-import { Rational } from "./rational";
-import { ISolution } from "./equation";
-import { Polynom } from "./polynom";
+import { Polynom } from './polynom';
+import { ISolution } from './equation';
+import { Rational } from './rational';
+
 export type StudyableFunction = Rational;
 export declare enum ZEROTYPE {
     ZERO = "z",

package/{esm → dist}/maths/geometry/circle.d.ts

@@ -1,16 +1,17 @@
-import { Point } from "./point";
-import { Line } from "./line";
-import { Fraction } from "../coefficients/fraction";
-import { Equation } from "../algebra/equation";
+import { Equation } from '../algebra/equation';
+import { Fraction } from '../coefficients/fraction';
+import { Line } from './line';
+import { Point } from './point';
+
 export declare class Circle {
-    constructor(...values: unknown[]);
     private _center;
-    get center(): Point;
     private _squareRadius;
-    get squareRadius(): Fraction;
     private _cartesian;
-    get cartesian(): Equation;
     private _exists;
+    constructor(...values: unknown[]);
+    get center(): Point;
+    get squareRadius(): Fraction;
+    get cartesian(): Equation;
     get exists(): boolean;
     get radius(): {
         tex: string;

package/{esm → dist}/maths/geometry/line.d.ts

@@ -1,10 +1,8 @@
-/**
- * This class works for 2d line in a plane.
- */
-import { Vector } from "./vector";
-import { Point } from "./point";
-import { Fraction } from "../coefficients/fraction";
-import { Equation } from "../algebra/equation";
+import { Equation } from '../algebra/equation';
+import { Fraction } from '../coefficients/fraction';
+import { Point } from './point';
+import { Vector } from './vector';
+
 export declare enum LinePropriety {
     None = 0,
     Parallel = "parallel",
@@ -17,25 +15,30 @@ export declare class Line {
     private _referencePropriety;
     private _referenceLine;
     private _reduceBeforeDisplay;
-    constructor(...values: unknown[]);
     private _a;
+    private _b;
+    private _c;
+    private _OA;
+    private _d;
+    private _n;
+    private _exists;
+    /**
+     * Value can be a mix of:
+     *
+     * @param values
+     */
+    constructor(...values: unknown[]);
     get a(): Fraction;
     set a(value: Fraction);
-    private _b;
     get b(): Fraction;
     set b(value: Fraction);
-    private _c;
     get c(): Fraction;
     set c(value: Fraction);
-    private _OA;
     get OA(): Point;
     set OA(value: Point);
-    private _d;
     get d(): Vector;
     set d(value: Vector);
-    private _n;
     get n(): Vector;
-    private _exists;
     get exists(): boolean;
     get equation(): Equation;
     get system(): {

package/{esm → dist}/maths/geometry/point.d.ts

@@ -1,10 +1,7 @@
-/**
- * Vector module contains everything necessary to handle 2d or 3d vectors.
- * @module Vector
- */
-import { Line } from "./line";
-import { Vector } from "./vector";
-import { Fraction } from "../coefficients/fraction";
+import { Fraction } from '../coefficients/fraction';
+import { Vector } from './vector';
+import { Line } from './line';
+
 export declare class Point {
     private _x;
     private _y;
@@ -17,18 +14,23 @@ export declare class Point {
     get tex(): string;
     get display(): string;
     get asVector(): Vector;
+    get key(): string;
+    static pmatrix: (a: any, b: any, c?: any) => string;
     parse: (...values: unknown[]) => Point;
     clone: () => Point;
     zero: () => Point;
     origin: () => Point;
     middleOf: (P1: Point, P2: Point) => Point;
+    translate: (value: {
+        x: number | Fraction;
+        y: number | Fraction;
+    }) => Point;
     texValues: (numberOfDigits: number) => string;
-    static pmatrix: (a: any, b: any, c?: any) => string;
     distanceTo: (item: Point | Line) => {
         value: number;
         fraction: Fraction;
         tex: string;
     };
-    get key(): string;
     isInListOfPoints: (list: Point[]) => boolean;
+    isEqual: (pt: Point) => boolean;
 }

package/{esm → dist}/maths/geometry/triangle.d.ts

@@ -1,6 +1,7 @@
-import { Point } from "./point";
-import { Vector } from "./vector";
-import { Line } from "./line";
+import { Line } from './line';
+import { Vector } from './vector';
+import { Point } from './point';
+
 export interface remarquableLines {
     'medians': {
         'A': Line;

package/{esm → dist}/maths/geometry/vector.d.ts

@@ -1,9 +1,6 @@
-/**
- * Vector module contains everything necessary to handle 2d or 3d vectors.
- * @module Vector
- */
-import { Fraction } from "../coefficients/fraction";
-import { Point } from "./point";
+import { Point } from './point';
+import { Fraction } from '../coefficients/fraction';
+
 export declare class Vector {
     private _x;
     private _y;
@@ -16,26 +13,26 @@ export declare class Vector {
     get norm(): number;
     get tex(): string;
     get asPoint(): Point;
+    get isNull(): boolean;
+    static scalarProduct: (v1: Vector, v2: Vector) => Fraction;
+    static determinant: (v1: Vector, v2: Vector) => Fraction;
     parse: (...values: any) => Vector;
     clone: () => Vector;
     reset: () => Vector;
     zero: () => Vector;
     one: () => Vector;
-    private _parseString;
     opposed: () => Vector;
     add: (V: Vector) => Vector;
     subtract: (V: Vector) => Vector;
     scalarProductWithVector: (V: Vector) => Fraction;
     determinantWithVector: (V: Vector) => Fraction;
-    static scalarProduct: (v1: Vector, v2: Vector) => Fraction;
-    static determinant: (v1: Vector, v2: Vector) => Fraction;
     normal: () => Vector;
     isColinearTo: (v: Vector) => boolean;
     isNormalTo: (v: Vector) => boolean;
-    get isNull(): boolean;
     multiplyByScalar: (k: any) => Vector;
     divideByScalar: (k: any) => Vector;
     simplify: () => Vector;
     simplifyDirection: () => Vector;
     angleWith: (V: Vector, sharp?: Boolean, radian?: Boolean) => number;
+    private _parseString;
 }

package/{esm → dist}/maths/randomization/random.d.ts

@@ -1,10 +1,12 @@
-import { randomCoefficientConfig, randomGeometryLineConfig, randomGeometryPointConfig, randomMonomConfig, randomPolynomConfig } from "./rndTypes";
-import { Polynom } from "../algebra/polynom";
-import { Monom } from "../algebra/monom";
-import { Fraction } from "../coefficients/fraction";
-import { Line } from "../geometry/line";
-import { Point } from "../geometry/point";
-export * from "./rndTypes";
+import { Circle } from '../geometry/circle';
+import { Point } from '../geometry/point';
+import { Line } from '../geometry/line';
+import { Fraction } from '../coefficients/fraction';
+import { Monom } from '../algebra/monom';
+import { Polynom } from '../algebra/polynom';
+import { randomCoefficientConfig, randomGeometryCircleConfig, randomGeometryLineConfig, randomGeometryPointConfig, randomMonomConfig, randomPolynomConfig } from './rndTypes';
+
+export * from './rndTypes';
 export declare namespace Random {
     function polynom(config?: randomPolynomConfig): Polynom;
     function monom(config?: randomMonomConfig): Monom;
@@ -19,5 +21,6 @@ export declare namespace Random {
     namespace Geometry {
         function line(config?: randomGeometryLineConfig): Line;
         function point(config?: randomGeometryPointConfig): Point;
+        function circle(config?: randomGeometryCircleConfig): Circle;
     }
 }

package/{esm → dist}/maths/randomization/rndFraction.d.ts

@@ -1,6 +1,7 @@
-import { randomCore } from "./randomCore";
-import { randomCoefficientConfig } from "./rndTypes";
-import { Fraction } from "../coefficients/fraction";
+import { Fraction } from '../coefficients/fraction';
+import { randomCoefficientConfig } from './rndTypes';
+import { randomCore } from './randomCore';
+
 /**
  * Create a random monom based on a based configuration
  */

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

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

package/{esm → dist}/maths/randomization/rndGeometryLine.d.ts

@@ -1,6 +1,7 @@
-import { randomCore } from "./randomCore";
-import { randomGeometryLineConfig } from "./random";
-import { Line } from "../geometry/line";
+import { Line } from '../geometry/line';
+import { randomGeometryLineConfig } from './random';
+import { randomCore } from './randomCore';
+
 /**
  * Create a random monom based on a based configuration
  */

package/{esm → dist}/maths/randomization/rndGeometryPoint.d.ts

@@ -1,6 +1,7 @@
-import { randomCore } from "./randomCore";
-import { randomGeometryPointConfig } from "./random";
-import { Point } from "../geometry/point";
+import { Point } from '../geometry/point';
+import { randomGeometryPointConfig } from './random';
+import { randomCore } from './randomCore';
+
 /**
  * Create a random monom based on a based configuration
  */

package/{esm → dist}/maths/randomization/rndMonom.d.ts

@@ -1,12 +1,13 @@
-import { randomCore } from "./randomCore";
-import { randomMonomConfig } from "./rndTypes";
-import { Monom } from "../algebra/monom";
+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;
-    constructor(userConfig?: randomMonomConfig);
     generate: () => Monom;
+    constructor(userConfig?: randomMonomConfig);
 }

package/{esm → dist}/maths/randomization/rndPolynom.d.ts

@@ -1,13 +1,14 @@
-import { randomCore } from "./randomCore";
-import { randomPolynomConfig } from "./rndTypes";
-import { Polynom } from "../algebra/polynom";
+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;
-    constructor(userConfig?: randomPolynomConfig);
     generate: () => Polynom;
+    constructor(userConfig?: randomPolynomConfig);
     factorable: () => Polynom;
 }

package/{esm → dist}/maths/randomization/rndTypes.d.ts

@@ -1,4 +1,5 @@
-import { Fraction } from "../coefficients/fraction";
+import { Fraction } from '../coefficients/fraction';
+
 export type randomCoefficientConfig = {
     negative?: boolean;
     max?: number;
@@ -32,3 +33,8 @@ export type randomGeometryPointConfig = {
     fraction?: boolean;
     max?: number;
 };
+export type randomGeometryCircleConfig = {
+    center?: randomGeometryPointConfig;
+    radius?: number;
+    pointsOnCircle?: number;
+};