pimath 0.0.128 → 0.0.130

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/dist/maths/algebra/equation.d.ts

@@ -0,0 +1,120 @@
+import { Fraction } from '../coefficients/fraction';
+import { literalType } from './monom';
+import { Polynom } from './polynom';
+
+/**
+ * Equation is a class to manage equations...
+ */
+export interface ISolution {
+    tex: string;
+    display: string;
+    value: number;
+    exact: unknown;
+}
+export declare enum PARTICULAR_SOLUTION {
+    real = "\\mathbb{R}",
+    varnothing = "\\varnothing"
+}
+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[]);
+    get left(): Polynom;
+    set left(value: Polynom);
+    get right(): Polynom;
+    set right(value: Polynom);
+    get sign(): string;
+    set sign(value: string);
+    get solutions(): ISolution[];
+    get isEquation(): boolean;
+    get solution(): string;
+    get isReal(): boolean;
+    get isVarnothing(): boolean;
+    get signAsTex(): string;
+    get tex(): string;
+    get display(): string;
+    get raw(): string;
+    get variables(): string[];
+    get numberOfVars(): number;
+    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;
+    randomize: (opts?: {}, sign?: string) => Equation;
+    /**
+     * Reorder will move all monoms containing a letter on the left, all the other on the right.
+     */
+    moveLeft: () => Equation;
+    reorder: (allLeft?: boolean) => Equation;
+    /**
+     * Multiply by the lcm denominator and divide by the gcm numerators.
+     */
+    simplify: () => Equation;
+    /**
+     * Reorder the polynom to have only one letter on the left, the rest on the right.
+     * @param letter
+     */
+    isolate: (letter?: string) => Equation | false;
+    replaceBy: (letter: string, P: Polynom) => Equation;
+    /**
+     * Multiple an equation by a fraction value.
+     * @param value
+     */
+    multiply: (value: unknown) => Equation;
+    /**
+     * divide an equation by a given value (transformed as a fraction)
+     *
+     * ```
+     * 8x+10=6x \vert 2
+     * 4x+5=3x
+     * ```
+     *
+     * |>Alternatively with $3x-4$ maybe it's working ?
+     * $$\frac{3x}{5}$$
+     *
+     * @param value
+     * @returns {Equation}
+     */
+    divide: (value: unknown) => Equation;
+    /**
+     * Get the degree of the equation
+     * @param letter
+     */
+    degree: (letter?: string) => Fraction;
+    /**
+     * Determine if the equation contains more than one letter/variable.
+     */
+    isMultiVariable: () => boolean;
+    letters: () => string[];
+    solve: () => Equation;
+    test: (values: literalType) => Boolean;
+    isSameAs: (equ: Equation) => Boolean;
+    isLinearTo: (equ: Equation) => Boolean;
+    private _findSign;
+    private _formatSign;
+    private _reverseSign;
+    private isGreater;
+    private isStrictEqual;
+    private isAlsoEqual;
+    private _solveDegree1;
+    private _solveDegree2;
+    private _solveDegree3plus;
+}

package/dist/maths/algebra/linearSystem.d.ts

@@ -0,0 +1,40 @@
+import { Fraction } from '../coefficients/fraction';
+import { Equation } from './equation';
+
+export declare class LinearSystem {
+    private _equations;
+    private _letters;
+    private _resolutionSteps;
+    private _solutions;
+    constructor(...equationStrings: (string | Equation)[]);
+    get equations(): Equation[];
+    set equations(value: Equation[]);
+    get letters(): string;
+    set letters(value: string);
+    get isSolvable(): boolean;
+    get variables(): string[];
+    get tex(): string;
+    get solution(): string;
+    get solutionAsDisplay(): 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;
+    solve: (withResolution?: boolean) => LinearSystem;
+    mergeEquations: (eq1: Equation, eq2: Equation, factor1: Fraction, factor2: Fraction) => Equation;
+    private _findLetters;
+    private _linearReduction;
+    /**
+     * Linear reduction of the equations to have only one letter
+     * @param letter    letter to isolate
+     * @private
+     */
+    private _solveOneLetter;
+}

package/dist/maths/algebra/logicalset.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Polynom module contains everything necessary to handle polynoms.
+ * @module Logicalset
+ */
+/**
+ * Polynom class can handle polynoms, reorder, resolve, ...
+ */
+export declare class Logicalset {
+    private _rawString;
+    private _rpn;
+    /**
+     *
+     * @param {string} value (optional) Default polynom to parse on class creation
+     */
+    constructor(value: string);
+    get isLogicalset(): boolean;
+    get rpn(): {
+        token: string;
+        tokenType: string;
+    }[];
+    get tex(): string;
+    evaluate(tokenSets: {
+        [key: string]: unknown[];
+    }, reference?: unknown[]): unknown[];
+    vennAB(): any[];
+    vennABC(): any[];
+    private parse;
+}

package/dist/maths/algebra/monom.d.ts

@@ -0,0 +1,207 @@
+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}\\).
+     * Examples: \\(3x^2\\) or \\(3/5x^2\\)
+     * @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);
+    /**
+     * Get the coefficient \\(k\\) of the Monom \\(k\\cdot x^{n}\\)
+     * @returns {Fraction}
+     */
+    get coefficient(): Fraction;
+    /**
+     * Set the coefficient \\(k\\) value of the monom
+     * @param {Fraction | number | string} F
+     */
+    set coefficient(F: Fraction | number | string);
+    /**
+     * 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}
+     */
+    get literal(): literalType;
+    /**
+     * Set the literal part of the monom. Must be a dictionary {x: Fraction, y: Fraction, ...}
+     * @param {literalType} L
+     */
+    set literal(L: literalType);
+    /**
+     * Get the literal square roots of the Monom.
+     * TODO: remove this getter ? Is it used and is it correct ?
+     * @returns {literalType}
+     */
+    get literalSqrt(): literalType;
+    /**
+     * Set the literal part of the monom from a string
+     * @param inputStr  String like x^2y^3
+     */
+    set literalStr(inputStr: string);
+    /**
+     * Get the variables letters
+     */
+    get variables(): string[];
+    /**
+     * This display getter is to be used in the polynom display getter
+     */
+    get display(): string;
+    get dividers(): Monom[];
+    /**
+     * Display the monom, forcing the '+' sign to appear
+     */
+    get displayWithSign(): string;
+    get texWithSign(): string;
+    get plotFunction(): string;
+    /**
+     * Get the tex output of the monom
+     */
+    get tex(): string;
+    /**
+     * Get the least common multiple of monoms
+     * @param monoms    Array of monoms
+     */
+    static lcm: (...monoms: Monom[]) => Monom;
+    /**
+     * Multiply two monoms and return a NEW monom.
+     * @param monoms
+     */
+    static xmultiply: (...monoms: Monom[]) => Monom;
+    /**
+     * Parse a string to a monom. The string may include fraction.
+     * @param inputStr
+     */
+    parse: (inputStr: unknown) => Monom;
+    addToken: (stack: Monom[], element: Token) => void;
+    /**
+     * Clone the current Monom.
+     */
+    clone: () => Monom;
+    copyLiterals: (literal: literalType) => literalType;
+    makeSame: (M: Monom) => Monom;
+    /**
+     * Create a zero value monom
+     */
+    zero: () => Monom;
+    /**
+     * Create a one value monom
+     */
+    one: () => Monom;
+    /**
+     * Clean the monom by removing each letters with a power of zero.
+     */
+    clean: () => Monom;
+    reduce: () => Monom;
+    /**
+     * Get the opposed
+     * Returns a monom.
+     */
+    opposed: () => Monom;
+    /**
+     * Add all similar monoms. If they aren't similar, they are simply skipped.
+     * @param M (Monom[]) The monoms to add.
+     */
+    add: (...M: Monom[]) => Monom;
+    /**
+     * Subtract multiple monoms
+     * @param M (Monom[]) The monoms to subtract
+     */
+    subtract: (...M: Monom[]) => Monom;
+    /**
+     * Multiple multiple monoms to the current monom
+     * @param M (Monom[]) The monoms to multiply to.
+     */
+    multiply: (...M: Monom[]) => Monom;
+    multiplyByNumber: (F: Fraction | number) => Monom;
+    /**
+     * Divide the current monoms by multiple monoms
+     * @param M (Monom[])
+     */
+    divide: (...M: Monom[]) => Monom;
+    /**
+     * Get the pow of a monom.
+     * @param nb (number) : Mathematical pow
+     */
+    pow: (nb: number | Fraction) => Monom;
+    /**
+     * Get the nth-root of the monom
+     * @param p
+     */
+    root: (p: number) => Monom;
+    /**
+     * Return the square root of a monom
+     */
+    sqrt: () => Monom;
+    compare: (M: Monom, sign?: string) => boolean;
+    /**
+     * Determine if the monom is null
+     */
+    isZero(): boolean;
+    /**
+     * Determine if the monom is one
+     */
+    isOne(): boolean;
+    /**
+     * Determine if two monoms are equals
+     * @param M
+     */
+    isEqual: (M: Monom) => boolean;
+    /**
+     * Determine if two monoms are similar
+     * @param M
+     */
+    isSameAs: (M: Monom) => boolean;
+    isSquare: () => boolean;
+    isLiteralSquare: () => boolean;
+    hasFractionCoefficient: () => boolean;
+    /**
+     * Determine if a monom contains a setLetter in it's literal part
+     * @param letter
+     */
+    hasLetter: (letter?: string) => boolean;
+    /**
+     * Set the power of a particular setLetter
+     * @param letter (string) Letter to change
+     * @param pow (number) Power of the setLetter (must be positive integer.
+     */
+    setLetter: (letter: string, pow: Fraction | number) => void;
+    /**
+     * Get the degree of a monom. If no setLetter is given, the result will be the global degree.
+     * @param letter (string) Letter to get to degree (power)
+     */
+    degree: (letter?: string) => Fraction;
+    /**
+     * Evaluate a monom. Each setLetter must be assigned to a Fraction.
+     * @param values    Dictionary of <setLetter: Fraction>
+     */
+    evaluate: (values: literalType | Fraction | number) => Fraction;
+    evaluateAsNumeric: (values: number | {
+        [Key: string]: number;
+    }) => number;
+    /**
+     * Derivative the monom
+     * @param letter
+     */
+    derivative: (letter?: string) => Monom;
+    primitive: (letter?: string) => Monom;
+    /**
+     * Determine if multiple monoms are similar
+     * @param M
+     */
+    areSameAs: (...M: Monom[]) => boolean;
+    /**
+     * Determine if multiple monoms are equals
+     * @param M
+     */
+    areEquals: (...M: Monom[]) => boolean;
+    isDivisible: (div: Monom) => boolean;
+    private _getLiteralDividers;
+    private _shutingYardToReducedMonom;
+}

package/dist/maths/algebra/polynom.d.ts

@@ -0,0 +1,155 @@
+import { ISolution } from './equation';
+import { Fraction } from '../coefficients/fraction';
+import { Token } from '../shutingyard.ts';
+import { literalType, Monom } from './monom';
+
+export type PolynomParsingType = string | Polynom | number | Fraction | Monom;
+export interface IEuclidian {
+    quotient: Polynom;
+    reminder: Polynom;
+}
+/**
+ * Polynom class can handle polynoms, reorder, resolve, ...
+ * ```
+ * let P = new Polynom('3x-4')
+ * ```
+ */
+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[]);
+    get dirty_factors(): boolean;
+    set dirty_factors(value: boolean);
+    get dirty_zeroes(): boolean;
+    set dirty_zeroes(value: boolean);
+    get euclidianCache(): {
+        [p: string]: IEuclidian;
+    };
+    set euclidianCache(value: {
+        [p: string]: IEuclidian;
+    });
+    get factors(): Polynom[];
+    set factors(value: Polynom[]);
+    get monoms(): Monom[];
+    set monoms(M: Monom[]);
+    get texString(): string;
+    get zeroes(): ISolution[];
+    get texFactors(): string;
+    get displayFactors(): string;
+    get length(): number;
+    get display(): string;
+    get raw(): string;
+    get tex(): string;
+    get isMultiVariable(): boolean;
+    get variables(): string[];
+    get numberOfVars(): number;
+    get plotFunction(): string;
+    mark_as_dirty: () => void;
+    addToken: (stack: Polynom[], element: Token) => void;
+    /**
+     * Parse a string to a polynom.
+     * @param inputStr
+     * @param values: as string, numbers or fractions
+     */
+    parse: (inputStr: PolynomParsingType, ...values: unknown[]) => Polynom;
+    /**
+     * Clone the polynom
+     */
+    clone: () => Polynom;
+    /**
+     * Set the polynom to zero.
+     * @returns {this}
+     */
+    zero: () => Polynom;
+    one: () => Polynom;
+    empty: () => Polynom;
+    opposed: () => Polynom;
+    add: (...values: unknown[]) => Polynom;
+    subtract: (...values: unknown[]) => Polynom;
+    multiply: (value: unknown) => Polynom;
+    /**
+     * Divide the current polynom by another polynom.
+     * @param P
+     * returns {quotient: Polynom, reminder: Polynom}
+     */
+    euclidian: (P: Polynom) => IEuclidian;
+    divide: (value: unknown) => Polynom;
+    pow: (nb: number) => Polynom;
+    /**
+     * Compare the current coefficient with another coefficient
+     * @param P
+     * @param sign (string| default is =): authorized values: =, <, <=, >, >= with some variations.
+     */
+    compare: (P: Polynom, sign?: string) => boolean;
+    isZero(): boolean;
+    isOne(): boolean;
+    isEqual: (P: Polynom) => boolean;
+    isSameAs: (P: Polynom) => boolean;
+    isOpposedAt: (P: Polynom) => boolean;
+    isFactorized: (polynomString: string, soft?: boolean) => boolean;
+    isReduced: (polynomString: string) => Boolean;
+    isDeveloped: (polynomString: string) => Boolean;
+    reduce: () => Polynom;
+    reorder: (letter?: string, revert?: boolean) => Polynom;
+    degree: (letter?: string) => Fraction;
+    letters: () => string[];
+    /**
+     * Replace a variable (letter) by a polynom.
+     * @param letter
+     * @param P
+     */
+    replaceBy: (letter: string, P: Polynom) => Polynom;
+    evaluate: (values: literalType | Fraction | number) => Fraction;
+    evaluateAsNumeric: (values: number | {
+        [Key: string]: number;
+    }) => number;
+    derivative: (letter?: string) => Polynom;
+    primitive: (letter?: string) => Polynom;
+    integrate: (a: Fraction | number, b: Fraction | number, letter?: string) => Fraction;
+    /**
+     * Factorize a polynom and store the best results in factors.
+     * @param maxValue Defines the greatest value to search to (default is 20).
+     */
+    factorize: (letter?: string) => Polynom[];
+    isDividableBy: (div: Polynom) => boolean;
+    getZeroes: () => ISolution[];
+    monomByDegree: (degree?: Fraction | number, letter?: string) => Monom;
+    monomsByDegree: (degree?: number | Fraction, letter?: string) => Monom[];
+    monomByLetter: (letter: string) => Monom;
+    getDenominators: () => number[];
+    getNumerators: () => number[];
+    lcmDenominator: () => number;
+    gcdDenominator: () => number;
+    lcmNumerator: () => number;
+    gcdNumerator: () => number;
+    commonMonom: () => Monom;
+    limitToInfinity: (letter?: string) => Fraction;
+    limitToNegativeInfinity: (letter?: string) => Fraction;
+    private _getAllPotentialFactors;
+    private _parseString;
+    private genDisplay;
+    /**
+     * Main parse using a shutting yard class
+     * @param inputStr
+     */
+    private shutingYardToReducedPolynom;
+    private multiplyByPolynom;
+    private multiplyByFraction;
+    private multiplyByInteger;
+    private multiplyByMonom;
+    private divideByInteger;
+    private divideByFraction;
+    private _factorize2ndDegree;
+    private _factorizeByGroups;
+}

package/dist/maths/algebra/rational.d.ts

@@ -0,0 +1,44 @@
+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
+ */
+export declare class Rational {
+    private _denominator;
+    private _numerator;
+    private _rawString;
+    /**
+     *
+     * @param numerator
+     * @param denominator
+     */
+    constructor(numerator?: Polynom | string, denominator?: Polynom | string);
+    get numerator(): Polynom;
+    get denominator(): Polynom;
+    get tex(): string;
+    get display(): string;
+    get texFactors(): string;
+    get displayFactors(): string;
+    get plotFunction(): string;
+    clone: () => Rational;
+    domain: () => string;
+    amplify: (P: Polynom) => Rational;
+    derivative: (letter?: string) => Rational;
+    factorize: (letter?: string) => Rational;
+    simplify: (P: Polynom) => Rational;
+    reduce: () => Rational;
+    opposed: () => Rational;
+    add: (R: Rational) => Rational;
+    subtract: (R: Rational) => Rational;
+    euclidian: () => IEuclidian;
+    limits: (value: Fraction | number, offset?: string, letter?: string) => Fraction;
+    evaluate: (values: literalType | Fraction | number) => Fraction;
+    evaluateAsNumeric: (values: number | {
+        [Key: string]: number;
+    }) => number;
+    study: (config?: StudyConfig | string) => RationalStudy;
+}

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;
+}