pimath 0.0.132 → 0.0.134

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

package/dist/pimath.d.ts

@@ -1,39 +0,0 @@
-import { Circle } from './maths/geometry/circle.ts';
-import { Triangle } from './maths/geometry/triangle.ts';
-import { Line } from './maths/geometry/line.ts';
-import { Point } from './maths/geometry/point.ts';
-import { Vector } from './maths/geometry/vector.ts';
-import { Random } from './maths/randomization/random.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 { NumExp } from './maths/numexp.ts';
-import { Numeric } from './maths/numeric.ts';
-import { Shutingyard } from './maths/shutingyard.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/lib/main.ts

@@ -1 +0,0 @@
-export {PiMath} from "./pimath.ts";