pimath 0.0.128 → 0.0.130

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

@@ -0,0 +1,140 @@
+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/coefficients/fraction.d.ts

@@ -0,0 +1,90 @@
+export type FractionParsingType = number | string | Fraction;
+/**
+ * The fraction class make possible to handle
+ * TODO: Write the documentation correctly.
+ * \\(\frac{a}{b}\\) or \\[\frac{a}{b}\\]  values.
+ */
+export declare class Fraction {
+    private _denominator;
+    private _numerator;
+    constructor(value?: unknown, denominatorOrPeriodic?: number);
+    get numerator(): number;
+    set numerator(value: number);
+    get denominator(): number;
+    set denominator(value: number);
+    get value(): number;
+    get tex(): string;
+    get texWithSign(): string;
+    get display(): string;
+    get frac(): string;
+    get dfrac(): string;
+    get tfrac(): string;
+    static max: (...fractions: (Fraction | number)[]) => Fraction;
+    static min: (...fractions: (Fraction | number)[]) => Fraction;
+    static average: (...fractions: (Fraction | number)[]) => Fraction;
+    static unique: (fractions: Fraction[], sorted?: boolean) => Fraction[];
+    static sort: (fractions: Fraction[], reverse?: boolean) => Fraction[];
+    isApproximative: () => boolean;
+    isExact: () => boolean;
+    /**
+     * Parse the value to get the numerator and denominator
+     * @param value : number or string to parse to get the fraction
+     * @param denominatorOrPeriodic (optional|number) : length of the periodic part: 2.333333 => 1 or denominator value
+     */
+    parse: (value: unknown, denominatorOrPeriodic?: number) => Fraction;
+    clone: () => Fraction;
+    zero: () => Fraction;
+    one: () => Fraction;
+    infinite: () => Fraction;
+    invalid: () => Fraction;
+    opposed: () => Fraction;
+    add: (F: Fraction | number) => Fraction;
+    subtract: (F: Fraction | number) => Fraction;
+    multiply: (F: Fraction | number) => Fraction;
+    xMultiply: (...values: (Fraction | number)[]) => Fraction;
+    divide: (F: Fraction | number) => Fraction;
+    invert: () => Fraction;
+    pow: (p: number | Fraction) => Fraction;
+    root: (p: number) => Fraction;
+    sqrt: () => Fraction;
+    abs: () => Fraction;
+    reduce: () => Fraction;
+    amplify: (k: number) => Fraction;
+    /**
+     * Compare the current coefficient with another coefficient
+     * @param F (Coefficient) The coefficient to compare
+     * @param sign (string| default is =): authorized values: =, <, <=, >, >= with some variations.
+     */
+    compare: (F: unknown, sign?: string) => boolean;
+    lesser: (than: Fraction | number) => Boolean;
+    leq: (than: Fraction | number) => Boolean;
+    greater: (than: Fraction | number) => Boolean;
+    geq: (than: Fraction | number) => Boolean;
+    isEqual: (than: Fraction | number) => boolean;
+    isNotEqual: (than: Fraction | number) => boolean;
+    isOpposed: (p: Fraction) => boolean;
+    isInverted: (p: Fraction) => boolean;
+    isZero: () => boolean;
+    isNotZero: () => boolean;
+    isOne: () => boolean;
+    isNegativeOne: () => boolean;
+    isPositive: () => boolean;
+    isNegative: () => boolean;
+    isStrictlyPositive: () => boolean;
+    isStrictlyNegative: () => Boolean;
+    isNaN: () => boolean;
+    isInfinity: () => boolean;
+    isFinite: () => boolean;
+    isSquare: () => boolean;
+    isReduced: () => boolean;
+    isNatural: () => boolean;
+    isRelative: () => boolean;
+    isRational: () => boolean;
+    isEven: () => boolean;
+    isOdd: () => boolean;
+    sign: () => number;
+    /**
+     * Simple function to determine if it's a fraction
+     */
+    areEquals: (...F: Fraction[]) => boolean;
+}

package/dist/maths/coefficients/nthRoot.d.ts

@@ -0,0 +1,23 @@
+/**
+ * NthRoot is something like "a+b\sqrt{3}
+ */
+export declare class NthRoot {
+    private _radical;
+    private _nth;
+    private _coefficient;
+    private _isValid;
+    constructor(...values: number[]);
+    get radical(): number;
+    set radical(value: number);
+    get nth(): number;
+    set nth(value: number);
+    get coefficient(): number;
+    set coefficient(value: number);
+    get tex(): string;
+    get display(): string;
+    get value(): number;
+    parse: (radical: number, nthroot?: number, coefficient?: number) => NthRoot;
+    reduce: () => NthRoot;
+    multiply: (N: NthRoot) => NthRoot;
+    hasRadical: () => boolean;
+}

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

@@ -0,0 +1,46 @@
+import { Equation } from '../algebra/equation';
+import { Fraction } from '../coefficients/fraction';
+import { Line } from './line';
+import { Point } from './point';
+
+export declare class Circle {
+    private _center;
+    private _squareRadius;
+    private _cartesian;
+    private _exists;
+    constructor(...values: unknown[]);
+    get center(): Point;
+    get squareRadius(): Fraction;
+    get cartesian(): Equation;
+    get exists(): boolean;
+    get radius(): {
+        tex: string;
+        display: string;
+        value: number;
+    };
+    get tex(): string;
+    get developed(): string;
+    get display(): string;
+    /**
+     * Get the relative position between circle and line. It corresponds to the number of intersection.
+     * @param {Line} L
+     * @returns {number}
+     */
+    relativePosition: (L: Line) => number;
+    lineIntersection: (L: Line) => Point[];
+    tangents: (P: Point | Fraction) => Line[];
+    isPointOnCircle: (P: Point) => Boolean;
+    getPointsOnCircle: (numberIsInteger?: boolean) => Point[];
+    clone(): Circle;
+    private _tangentsThroughOnePointOnTheCircle;
+    private _tangentsThroughOnePointOutsideTheCircle;
+    private _tangentsWithSlope;
+    private _reset;
+    private parse;
+    private _calculateCartesian;
+    private _parseCopyCircle;
+    private _parseCenterAndRadius;
+    private _parseCenterAndPointThrough;
+    private _parseEquation;
+    private _parseThroughtThreePoints;
+}

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

@@ -0,0 +1,102 @@
+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",
+    Perpendicular = "perpendicular",
+    Tangent = "tangent"
+}
+export declare class Line {
+    static PERPENDICULAR: LinePropriety;
+    static PARALLEL: LinePropriety;
+    private _referencePropriety;
+    private _referenceLine;
+    private _reduceBeforeDisplay;
+    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);
+    get b(): Fraction;
+    set b(value: Fraction);
+    get c(): Fraction;
+    set c(value: Fraction);
+    get OA(): Point;
+    set OA(value: Point);
+    get d(): Vector;
+    set d(value: Vector);
+    get n(): Vector;
+    get exists(): boolean;
+    get equation(): Equation;
+    get system(): {
+        x: Equation;
+        y: Equation;
+    };
+    get tex(): {
+        canonical: string;
+        mxh: string;
+        parametric: string;
+        equation: string;
+        system: string;
+    };
+    get reduceBeforeDisplay(): boolean;
+    set reduceBeforeDisplay(value: boolean);
+    get display(): {
+        canonical: string;
+        mxh: string;
+        parametric: string;
+    };
+    get normal(): Vector;
+    get director(): Vector;
+    get slope(): Fraction;
+    get height(): Fraction;
+    randomPoint: (k?: number) => Point;
+    randomNearPoint: (k?: number) => Point;
+    /**
+     * Parse data to a line
+     * @param {any} values
+     * @returns {Line}
+     */
+    parse: (...values: unknown[]) => Line;
+    parseEquation: (equ: Equation) => Line;
+    parseByCoefficient: (a: Fraction | number, b: Fraction | number, c: Fraction | number) => Line;
+    parseByPointAndVector: (P: Point, d: Vector) => Line;
+    parseByPointAndNormal: (P: Point, n: Vector) => Line;
+    parseByPointAndLine: (P: Point, L: Line, orientation?: LinePropriety) => Line;
+    clone: () => Line;
+    isOnLine: (pt: Point) => Boolean;
+    isParallelTo: (line: Line) => Boolean;
+    isSameAs: (line: Line) => Boolean;
+    isPerpendicularTo: (line: Line) => Boolean;
+    isVertical: () => Boolean;
+    simplify: () => Line;
+    simplifyDirection: () => Line;
+    intersection: (line: Line) => {
+        point: Point;
+        hasIntersection: boolean;
+        isParallel: boolean;
+        isSame: boolean;
+    };
+    distanceTo(pt: Point): {
+        value: number;
+        fraction: Fraction;
+        tex: string;
+    };
+    hitSegment(A: Point, B: Point): boolean;
+    getValueAtX: (value: Fraction | number) => Fraction;
+    getValueAtY: (value: Fraction | number) => Fraction;
+    canonicalAsFloatCoefficient(decimals: number): string;
+}

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

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

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

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

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

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

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

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

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

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