pimath 0.0.132 → 0.0.134

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

@@ -1,28 +0,0 @@
-/**
- * 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/polynom.d.ts

@@ -1,155 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/dist/maths/algebra/study.d.ts

@@ -1,140 +0,0 @@
-import { Polynom } from './polynom';
-import { ISolution } from './equation';
-import { Rational } from './rational';
-
-export type StudyableFunction = Rational;
-export declare enum ZEROTYPE {
-    ZERO = "z",
-    DEFENCE = "d",
-    NOTHING = "t"
-}
-export interface IZero extends ISolution {
-    extrema: FUNCTION_EXTREMA;
-    type: ZEROTYPE;
-}
-export declare enum ASYMPTOTE {
-    VERTICAL = "av",
-    HORIZONTAL = "ah",
-    SLOPE = "ao",
-    HOLE = "hole"
-}
-export declare enum ASYMPTOTE_POSITION {
-    "LT" = "LT",
-    "RT" = "RT",
-    "LB" = "LB",
-    "RB" = "RB"
-}
-export interface IAsymptote {
-    deltaX: StudyableFunction;
-    display: string;
-    fx: Polynom;
-    limits: string;
-    position: ASYMPTOTE_POSITION[];
-    tableOfSign: ITableOfSigns;
-    tex: string;
-    type: ASYMPTOTE;
-    zero: IZero;
-}
-export declare enum FUNCTION_EXTREMA {
-    MIN = "min",
-    MAX = "max",
-    FLAT = "flat",
-    NOTHING = ""
-}
-export interface IExtrema {
-    tex: {
-        x: string;
-        y: string;
-    };
-    type: FUNCTION_EXTREMA;
-    value: {
-        x: number;
-        y: number;
-    };
-}
-export interface ITableOfSigns {
-    extremes: {
-        [Key: string]: IExtrema;
-    };
-    factors: Polynom[];
-    fx: StudyableFunction;
-    signs: (string[])[];
-    tex: string;
-    type: TABLE_OF_SIGNS;
-    zeroes: IZero[];
-}
-export declare enum TABLE_OF_SIGNS {
-    SIGNS = "signs",
-    GROWS = "grows",
-    VARIATIONS = "variatins"
-}
-export interface StudyConfig {
-    asymptotes?: boolean;
-    derivative?: boolean;
-    domain?: boolean;
-    name?: string;
-    variable?: string;
-    signs?: boolean;
-    variations?: boolean;
-}
-/**
- * The study class is a "function study" class that will get:
- * fx               : get the function
- * domain           : string
- * zeroes           : Object (tex, IZero)
- * signs            : table of signs + tex output  using tkz-tab
- * av               : vertical asymptotic
- * ah               : horizontal asymptotic
- * ao               : obliques
- * deltaX           : position relative
- * dx               : derivative
- * grows            : growing table + tex output  using tkz-tab
- * ddx              : dérivée seconde
- * variations       : variation table + tex output  using tkz-tab
- */
-export declare class Study {
-    fx: StudyableFunction;
-    private _asymptotes;
-    private _derivative;
-    private _signs;
-    private _variations;
-    private _zeroes;
-    private _config;
-    private _name;
-    constructor(fx: StudyableFunction, config?: StudyConfig | string);
-    get name(): string;
-    set name(value: string);
-    get config(): StudyConfig;
-    set config(value: StudyConfig);
-    get zeroes(): IZero[];
-    get domain(): string;
-    get signs(): ITableOfSigns;
-    get asymptotes(): IAsymptote[];
-    get derivative(): ITableOfSigns;
-    get texSigns(): string;
-    get texGrows(): string;
-    get texVariations(): string;
-    makeStudy: () => void;
-    indexOfZero: (zeroes: IZero[], zero: IZero | ISolution) => number;
-    makeOneLineForSigns: (factor: Polynom, zeroes: IZero[], zeroSign: ZEROTYPE) => string[];
-    makeSignsResult: (signs: (string[])[]) => string[];
-    makeGrowsResult: (tos: ITableOfSigns) => {
-        growsLine: string[];
-        extremes: {
-            [Key: string]: IExtrema;
-        };
-    };
-    makeVariationsResult: (tos: ITableOfSigns) => {
-        varsLine: string[];
-        extremes: {
-            [Key: string]: IExtrema;
-        };
-    };
-    makeZeroes(): IZero[];
-    makeSigns(): ITableOfSigns;
-    makeAsymptotes(): IAsymptote[];
-    makeDerivative(): ITableOfSigns;
-    makeVariation(): ITableOfSigns;
-    drawCode: () => string;
-    private _makeTexFromTableOfSigns;
-}

package/dist/maths/geometry/point.d.ts

@@ -1,36 +0,0 @@
-import { Fraction } from '../coefficients/fraction';
-import { Vector } from './vector';
-import { Line } from './line';
-
-export declare class Point {
-    private _x;
-    private _y;
-    private _exist;
-    constructor(...values: unknown[]);
-    get x(): Fraction;
-    set x(value: Fraction);
-    get y(): Fraction;
-    set y(value: Fraction);
-    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;
-    distanceTo: (item: Point | Line) => {
-        value: number;
-        fraction: Fraction;
-        tex: string;
-    };
-    isInListOfPoints: (list: Point[]) => boolean;
-    isEqual: (pt: Point) => boolean;
-}

package/dist/maths/geometry/triangle.d.ts

@@ -1,92 +0,0 @@
-import { Line } from './line';
-import { Vector } from './vector';
-import { Point } from './point';
-
-export interface remarquableLines {
-    'medians': {
-        'A': Line;
-        'B': Line;
-        'C': Line;
-        'intersection': Point;
-    };
-    'mediators': {
-        'AB': Line;
-        'AC': Line;
-        'BC': Line;
-        'intersection': Point;
-    };
-    'heights': {
-        'A': Line;
-        'B': Line;
-        'C': Line;
-        'intersection': Point;
-    };
-    'bisectors': {
-        'A': Line;
-        'B': Line;
-        'C': Line;
-        'intersection': Point;
-    };
-    externalBisectors: {
-        'A': Line;
-        'B': Line;
-        'C': Line;
-        'intersection': Point;
-    };
-}
-export declare class Triangle {
-    private _A;
-    private _B;
-    private _C;
-    private _lines;
-    private _middles;
-    private _remarquables;
-    constructor(...values: unknown[]);
-    get A(): Point;
-    get B(): Point;
-    get C(): Point;
-    get AB(): Vector;
-    get BA(): Vector;
-    get BC(): Vector;
-    get CB(): Vector;
-    get AC(): Vector;
-    get CA(): Vector;
-    get isRectangle(): boolean;
-    get isEquilateral(): boolean;
-    get isIsocele(): boolean;
-    get lines(): {
-        'AB': Line;
-        'BC': Line;
-        'AC': Line;
-    };
-    get remarquables(): remarquableLines;
-    /**
-     * Parse values to a triangle. Supported formats:
-     * Point, Point, Point
-     * x1, y1, x2, y2, x3, y3
-     * TODO: Something else ?
-     * @param values
-     */
-    parse: (...values: any) => Triangle;
-    /**
-     * Clone the Triangle class
-     */
-    clone: () => Triangle;
-    /**
-     * Generate the Line object for the three segments of the triangle
-     */
-    private _updateTriangle;
-    /**
-     * Get the Point class for the given name
-     * @param ptName
-     */
-    private getPointByName;
-    /**
-     * Get the vector for the segment given by name.
-     * @param ptName1
-     * @param ptName2
-     */
-    private getSegment;
-    private _calculateRemarquableLines;
-    private _calculateBisectors;
-}

package/dist/maths/geometry/vector.d.ts

@@ -1,38 +0,0 @@
-import { Point } from './point';
-import { Fraction } from '../coefficients/fraction';
-
-export declare class Vector {
-    private _x;
-    private _y;
-    constructor(...values: unknown[]);
-    get x(): Fraction;
-    set x(value: Fraction | number | string);
-    get y(): Fraction;
-    set y(value: Fraction | number | string);
-    get normSquare(): Fraction;
-    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;
-    opposed: () => Vector;
-    add: (V: Vector) => Vector;
-    subtract: (V: Vector) => Vector;
-    scalarProductWithVector: (V: Vector) => Fraction;
-    determinantWithVector: (V: Vector) => Fraction;
-    normal: () => Vector;
-    isColinearTo: (v: Vector) => boolean;
-    isNormalTo: (v: Vector) => boolean;
-    multiplyByScalar: (k: any) => Vector;
-    divideByScalar: (k: any) => Vector;
-    simplify: () => Vector;
-    simplifyDirection: () => Vector;
-    angleWith: (V: Vector, sharp?: Boolean, radian?: Boolean) => number;
-    private _parseString;
-}

package/dist/maths/numeric.d.ts

@@ -1,28 +0,0 @@
-export declare class Numeric {
-    static round(value: number, decimals?: number): number;
-    /**
-     * Get the list of the nth first prime numbers.
-     * @param nb : number of primes to choose from
-     */
-    static primes(nb?: number): number[];
-    /**
-     * Get the list of all dividers of a number.
-     * @param value
-     */
-    static dividers(value: number): number[];
-    /**
-     * Great Common Divisor
-     * @param values : number values
-     */
-    static gcd(...values: number[]): number;
-    static divideNumbersByGCD(...values: number[]): number[];
-    /**
-     * Least Common Multiple
-     * @param values: list of numbers
-     */
-    static lcm(...values: number[]): number;
-    static pythagoricianTripletsWithTarget(target: number, targetIsSquare?: boolean): number[][];
-    static numberCorrection(value: number, epsilonDigit?: number, epsilonNumberOfDigits?: number, number_of_digits?: number): number;
-    static periodic(value: number): number;
-    static decompose(value: number): number[][];
-}

package/dist/maths/numexp.d.ts

@@ -1,19 +0,0 @@
-export declare class NumExp {
-    private _rpn;
-    private _expression;
-    private _isValid;
-    constructor(value: string, uniformize?: boolean);
-    get rpn(): {
-        token: string;
-        tokenType: string;
-    }[];
-    get isValid(): boolean;
-    set isValid(value: boolean);
-    get expression(): string;
-    evaluate(values?: {
-        [Key: string]: number;
-    }): number;
-    private _extractDecimalPart;
-    private _numberCorrection;
-    private _addToStack;
-}

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

@@ -1,26 +0,0 @@
-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;
-    function fraction(config?: randomCoefficientConfig): Fraction;
-    function number(from: number, to: number, exclude?: number[]): number;
-    function numberSym(max: number, allowZero?: boolean): number;
-    function prime(max: number): number;
-    function bool(percent?: number): boolean;
-    function array(arr: any[], number?: number): any[];
-    function item(arr: any[]): any;
-    function shuffle(arr: any[]): any[];
-    namespace Geometry {
-        function line(config?: randomGeometryLineConfig): Line;
-        function point(config?: randomGeometryPointConfig): Point;
-        function circle(config?: randomGeometryCircleConfig): Circle;
-    }
-}

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

@@ -1,7 +0,0 @@
-export declare class randomCore {
-    protected _config: Object;
-    protected _defaultConfig: Object;
-    mergeConfig: (config: Object, defaultConfig: Object) => Object;
-    generate: () => unknown;
-    config: (config: Object) => randomCore;
-}

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

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

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

@@ -1,13 +0,0 @@
-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/dist/maths/randomization/rndGeometryLine.d.ts

@@ -1,13 +0,0 @@
-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;
-}