pimath 0.0.133 → 0.1.0

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

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

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

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

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

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

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

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