pimath 0.0.131 → 0.0.133

package/lib/maths/randomization/random.ts

@@ -1,80 +0,0 @@
-import {rndPolynom} from "./rndPolynom";
-import {rndMonom} from "./rndMonom";
-import {rndHelpers} from "./rndHelpers";
-import {
-    randomCoefficientConfig,
-    randomGeometryCircleConfig,
-    randomGeometryLineConfig,
-    randomGeometryPointConfig,
-    randomMonomConfig,
-    randomPolynomConfig
-} from "./rndTypes";
-import {rndFraction} from "./rndFraction";
-import {Polynom} from "../algebra/polynom";
-import {Monom} from "../algebra/monom";
-import {Fraction} from "../coefficients/fraction";
-import {Line} from "../geometry/line";
-import {rndGeometryLine} from "./rndGeometryLine";
-import {Point} from "../geometry/point";
-import {rndGeometryPoint} from "./rndGeometryPoint";
-import {Circle} from "../geometry/circle";
-import {rndGeometryCircle} from "./rndGeometryCircle";
-
-export * from "./rndTypes"
-
-export namespace Random {
-    export function polynom(config?: randomPolynomConfig): Polynom {
-        return (new rndPolynom(config)).generate()
-    }
-
-    export function monom(config?: randomMonomConfig): Monom {
-        return (new rndMonom(config)).generate()
-    }
-
-    export function fraction(config?: randomCoefficientConfig): Fraction {
-        return (new rndFraction(config)).generate()
-    }
-
-    export function number(from: number, to: number, exclude?: number[]): number {
-        return rndHelpers.randomInt(from, to, exclude)
-    }
-
-    export function numberSym(max: number, allowZero?: boolean): number {
-        return rndHelpers.randomIntSym(max, allowZero)
-    }
-
-    export function prime(max: number): number {
-        return rndHelpers.randomPrime(max)
-    }
-
-    export function bool(percent?: number): boolean {
-        return rndHelpers.randomBool(percent)
-    }
-
-    export function array(arr: any[], number?: number): any[] {
-        return rndHelpers.randomArray(arr, number)
-    }
-
-    export function item(arr: any[]): any {
-        return rndHelpers.randomItem(arr)
-    }
-
-    export function shuffle(arr: any[]): any[] {
-        return rndHelpers.shuffleArray(arr)
-    }
-
-    export namespace Geometry {
-        export function line(config?: randomGeometryLineConfig): Line {
-            return (new rndGeometryLine(config).generate())
-        }
-
-        export function point(config?: randomGeometryPointConfig): Point {
-            return (new rndGeometryPoint(config).generate())
-        }
-
-        export function circle(config?: randomGeometryCircleConfig): Circle {
-            return (new rndGeometryCircle(config).generate())
-        }
-
-    }
-}

package/lib/maths/randomization/randomCore.ts

@@ -1,19 +0,0 @@
-export class randomCore {
-    protected _config: Object
-    protected _defaultConfig: Object
-    mergeConfig = (config: Object, defaultConfig: Object): Object => {
-        if (config !== undefined) {
-            return {...defaultConfig, ...config}
-        }
-        return defaultConfig
-    }
-
-    generate = (): unknown => {
-        return undefined
-    }
-
-    config = (config: Object): randomCore => {
-        this._config = this.mergeConfig(config, this._defaultConfig)
-        return this
-    }
-}

package/lib/maths/randomization/rndFraction.ts

@@ -1,47 +0,0 @@
-import {randomCore} from "./randomCore";
-import {randomCoefficientConfig, randomMonomConfig, randomPolynomConfig} from "./rndTypes";
-import {Random} from "./random";
-import {Fraction} from "../coefficients/fraction";
-
-/**
- * Create a random monom based on a based configuration
- */
-export class rndFraction extends randomCore {
-    declare protected _config: randomCoefficientConfig
-    declare protected _defaultConfig: randomCoefficientConfig
-
-    constructor(userConfig?: randomCoefficientConfig) {
-        super();
-
-        this._defaultConfig = {
-            negative: true,
-            max: 10,
-            reduced: true,
-            zero: true,
-            natural: false
-        }
-
-        this._config = this.mergeConfig(userConfig, this._defaultConfig)
-    }
-
-    generate = (): Fraction => {
-        let Q = new Fraction()
-
-        if(this._config.negative){
-            Q.numerator = Random.numberSym(this._config.max, this._config.zero)
-        }else {
-            Q.numerator = Random.number(this._config.zero ? 0 : 1, this._config.max)
-        }
-        if(this._config.natural){
-            Q.denominator = 1
-        }else {
-            let securityCount = 0
-            while(Q.isRelative() && securityCount<10) {
-                Q.denominator = Random.number(1, this._config.max)
-                securityCount++
-            }
-        }
-
-        return this._config.reduced?Q.reduce():Q
-    }
-}

package/lib/maths/randomization/rndGeometryCircle.ts

@@ -1,50 +0,0 @@
-import {randomCore} from "./randomCore";
-import {Random, randomGeometryCircleConfig} from "./random";
-import {Circle} from "../geometry/circle";
-
-/**
- * Create a random monom based on a based configuration
- */
-export class rndGeometryCircle extends randomCore {
-    declare protected _config: randomGeometryCircleConfig
-    declare protected _defaultConfig: randomGeometryCircleConfig
-
-    generate = (): Circle => {
-        const center = Random.Geometry.point(this._config.center)
-
-        let rv, r
-        if (this._config.pointsOnCircle === 8) {
-            rv = Random.number(1, 3),
-                r = rv ** 2 + (rv + 1) ** 2
-        } else {
-            r = Random.number(1, 20)
-        }
-
-        const c = new Circle(center, r, true)
-
-
-        // let pts = c.getPointsOnCircle(true)
-        //
-        // pts = Random.shuffle(pts)
-        // let ptt = pts.shift(),
-        //     pt1 = pts.shift(),
-        //     pt2
-        //
-        // for (let pt of pts) {
-        //     if (!pt1.x.isEqual(pt.x) && !pt1.y.isEqual(pt.y) && !A.isEqual(new Point().middleOf(pt1, pt))) {
-        //         pt2 = pt.clone()
-        //         break
-        //     }
-        // }
-
-        return c
-
-    }
-
-    constructor(userConfig?: randomGeometryCircleConfig) {
-        super();
-
-        this._defaultConfig = {}
-        this._config = this.mergeConfig(userConfig, this._defaultConfig)
-    }
-}

package/lib/maths/randomization/rndGeometryLine.ts

@@ -1,53 +0,0 @@
-import {randomCore} from "./randomCore";
-import {Random, randomGeometryLineConfig} from "./random";
-import {Line} from "../geometry/line";
-import {Vector} from "../geometry/vector";
-import {Point} from "../geometry/point";
-
-/**
- * Create a random monom based on a based configuration
- */
-export class rndGeometryLine extends randomCore {
-    declare protected _config: randomGeometryLineConfig
-    declare protected _defaultConfig: randomGeometryLineConfig
-
-    constructor(userConfig?: randomGeometryLineConfig) {
-        super();
-
-        this._defaultConfig = {
-            A: {
-                x: Random.numberSym(10),
-                y: Random.numberSym(10)
-            },
-        }
-
-        // TODO: Strange that it raise an error
-        // @ts-ignore
-        this._config = this.mergeConfig(userConfig, this._defaultConfig)
-    }
-
-    generate = (): Line => {
-        // The A point exists.
-        const d = new Vector(
-            Random.numberSym(10),
-            Random.numberSym(10)
-        )
-
-        while (d.isNull) {
-            d.x = Random.numberSym(10)
-            d.y = Random.numberSym(10)
-        }
-
-        if (this._config.slope === 1) {
-            if (d.x.sign() !== d.y.sign()) {
-                d.y.opposed()
-            }
-        } else if (this._config.slope === -1) {
-            if (d.x.sign() !== d.y.sign()) {
-                d.y.opposed()
-            }
-        }
-
-        return new Line(new Point(this._config.A.x, this._config.A.y), d)
-    }
-}

package/lib/maths/randomization/rndGeometryPoint.ts

@@ -1,69 +0,0 @@
-import {randomCore} from "./randomCore";
-import {Random, randomGeometryPointConfig} from "./random";
-import {Point} from "../geometry/point";
-import {Fraction} from "../coefficients/fraction";
-
-/**
- * Create a random monom based on a based configuration
- */
-export class rndGeometryPoint extends randomCore {
-    declare protected _config: randomGeometryPointConfig
-    declare protected _defaultConfig: randomGeometryPointConfig
-
-    constructor(userConfig?: randomGeometryPointConfig) {
-        super();
-
-        this._defaultConfig = {
-            axis: true,
-            fraction: false,
-            max: 10
-        }
-
-        this._config = this.mergeConfig(userConfig, this._defaultConfig)
-    }
-
-    generate = (): Point => {
-        let x: Fraction, y: Fraction,
-            zeroX = this._config.axis === true || this._config.axis === 'x',
-            zeroY = this._config.axis === true || this._config.axis === 'y'
-
-        x = this._config.fraction ?
-            Random.fraction({max: this._config.max, zero: zeroX}) :
-            new Fraction(Random.numberSym(this._config.max, zeroX))
-
-        y = this._config.fraction ?
-            Random.fraction({max: this._config.max, zero: zeroY}) :
-            new Fraction(Random.numberSym(this._config.max, zeroY))
-
-        if (+this._config.quadrant === 1) {
-            x.abs()
-            y.abs()
-        }
-        if (+this._config.quadrant === 2) {
-            if (x.isPositive()) {
-                x.opposed()
-            }
-            if (y.isNegative()) {
-                y.opposed()
-            }
-        }
-        if (+this._config.quadrant === 3) {
-            if (x.isPositive()) {
-                x.opposed()
-            }
-            if (y.isPositive()) {
-                y.opposed()
-            }
-        }
-        if (+this._config.quadrant === 4) {
-            if (x.isNegative()) {
-                x.opposed()
-            }
-            if (y.isPositive()) {
-                y.opposed()
-            }
-        }
-
-        return new Point(x, y)
-    }
-}

package/lib/maths/randomization/rndHelpers.ts

@@ -1,107 +0,0 @@
-/**
- * Random helpers
- */
-import {Numeric} from "../numeric.ts";
-
-export class rndHelpers {
-
-    /**
-     * Random boolean with a percent ratio
-     * @param percent
-     */
-    static randomBool(percent: number = 0.5): boolean {
-        return Math.random() < percent;
-    }
-
-    /**
-     * 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 {
-        if (b === undefined) {
-            if (a >= 0) {
-                return this.randomInt(0, a);
-            } else {
-                return this.randomInt(a, 0);
-            }
-        }
-
-        // Same start and end values
-        if (a === b) {
-            return a
-        }
-
-        // No exclusion
-        if (exclude === undefined) {
-            return Math.floor(Math.random() * (b - a + 1) + a);
-        }
-
-        // With exclusion
-        if (Math.abs(b - a) <= exclude.length) {
-            throw new Error('The number of excluded values is too high.')
-        }
-
-        let r = this.randomInt(a, b)
-        while (exclude.includes(r)) {
-            r = this.randomInt(a, b)
-        }
-        return r
-    }
-
-    /**
-     * 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 {
-        if (zero === false) {
-            return this.randomBool() ? this.randomInt(1, max) : -this.randomInt(1, max);
-        } else {
-            return this.randomInt(-max, max);
-        }
-    }
-
-    static randomPrime(max: number): number {
-        let primes = Numeric.primes()
-        if (max !== undefined) {
-            primes = primes.filter(x => x < max)
-        }
-        return this.randomItem(primes)
-    }
-
-    static randomArray(arr: any[], number?: number): any[] {
-        if (number === undefined) {
-            number = 1
-        }
-
-        // Return a clone array
-        if (arr.length <= 0) {
-            return Object.values(arr)
-        }
-
-        // Randomize the array and return the n first elements.
-        return rndHelpers.shuffleArray(arr).slice(0, number);
-    }
-
-    static randomItem(arr: any[]): any {
-        if (arr.length === 0) {
-            return ''
-        }
-        return arr[this.randomInt(0, arr.length - 1)]
-    }
-
-    static shuffleArray(arr: any[]): any[] {
-        // The Fisher-Yates algorithm
-        let shuffleArray = Object.values(arr)
-        for (let i = shuffleArray.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            const temp = shuffleArray[i];
-            shuffleArray[i] = shuffleArray[j];
-            shuffleArray[j] = temp;
-        }
-
-        return shuffleArray;
-    }
-
-}

package/lib/maths/randomization/rndMonom.ts

@@ -1,57 +0,0 @@
-import {randomCore} from "./randomCore";
-import {randomMonomConfig} from "./rndTypes";
-import {Random} from "./random";
-import {Monom} from "../algebra/monom";
-
-/**
- * Create a random monom based on a based configuration
- */
-export class rndMonom extends randomCore {
-    declare protected _config: randomMonomConfig
-    declare protected _defaultConfig: randomMonomConfig
-
-    generate = (): Monom => {
-        // Create a monom instance
-        let M = new Monom()
-
-        // Generate the coefficient
-        if (typeof this._config.fraction === "boolean") {
-            M.coefficient = Random.fraction({
-                zero: this._config.zero,
-                reduced: true,
-                natural: !this._config.fraction
-            })
-        } else {
-            M.coefficient = Random.fraction(this._config.fraction)
-        }
-
-        // Calculate the degree of the monom
-        if (this._config.letters.length > 1) {
-            // Initialise each items...
-            for (let L of this._config.letters.split('')) {
-                M.setLetter(L, 0);
-            }
-            for (let i = 0; i < this._config.degree; i++) {
-                const L = Random.item(this._config.letters.split(""))
-                M.setLetter(L, M.degree(L).clone().add(1))
-            }
-        } else {
-            M.setLetter(this._config.letters, this._config.degree)
-        }
-
-        return M
-    }
-
-    constructor(userConfig?: randomMonomConfig) {
-        super();
-
-        this._defaultConfig = {
-            letters: 'x',
-            degree: 2,
-            fraction: true,
-            zero: false
-        }
-
-        this._config = this.mergeConfig(userConfig, this._defaultConfig)
-    }
-}

package/lib/maths/randomization/rndPolynom.ts

@@ -1,90 +0,0 @@
-import {randomCore} from "./randomCore";
-import {randomPolynomConfig} from "./rndTypes";
-import {rndMonom} from "./rndMonom";
-import {Random} from "./random";
-import {Polynom} from "../algebra/polynom";
-import {Monom} from "../algebra/monom";
-
-/**
- * Random polynoms
- */
-export class rndPolynom extends randomCore {
-    declare protected _config: randomPolynomConfig
-    declare protected _defaultConfig: randomPolynomConfig
-
-    generate = (): Polynom => {
-        if (this._config.factorable && this._config.degree > 1) {
-            return this.factorable()
-        }
-
-        // Create the polynom
-        let P = new Polynom().empty(),
-            M: Monom
-
-        for (let i = this._config.degree; i >= 0; i--) {
-            // Create monom of corresponding degree.
-            M = new rndMonom({
-                letters: this._config.letters,
-                degree: i,
-                fraction: this._config.fraction,
-                zero: (i === this._config.degree) ? false : this._config.allowNullMonom
-            }).generate()
-
-            // If degree is the greatest and unit is true, set the monom value to one.
-            if (this._config.unit && this._config.degree === i) {
-                M.coefficient.one()
-            }
-
-            // Add to the polynom
-            P.add(M)
-        }
-
-        // Make sure the first monom is positive.
-        if (this._config.positive && P.monomByDegree().coefficient.isNegative()) {
-            P.monomByDegree().coefficient.opposed()
-        }
-
-        // If the number of monoms is greater than the allowed value, remove some of them... except the first one !
-        if (this._config.numberOfMonoms > 0 && this._config.numberOfMonoms < P.length) {
-            // Get the greatest degree monom
-            let M = P.monomByDegree().clone()
-            P.monoms = Random.array(P.monoms.slice(1), this._config.numberOfMonoms - 1)
-            P.add(M).reorder().reduce()
-        }
-        return P
-    }
-
-    constructor(userConfig?: randomPolynomConfig) {
-        super();
-
-        // Default config for a random polynom
-        this._defaultConfig = {
-            letters: 'x',
-            degree: 2,
-            fraction: false,
-            zero: false,
-            unit: false,
-            factorable: false,
-            allowNullMonom: true,
-            numberOfMonoms: 0,
-            positive: true
-        }
-
-        // Merge config with initialiser
-        this._config = this.mergeConfig(userConfig, this._defaultConfig)
-    }
-
-    factorable = (): Polynom => {
-        let P = new Polynom().one()
-
-        let _factorableConfig = {...this._config}
-        _factorableConfig.degree = 1
-        _factorableConfig.factorable = false
-
-        for (let i = 0; i < this._config.degree; i++) {
-            P.multiply(Random.polynom(_factorableConfig))
-        }
-
-        return P
-    }
-}

package/lib/maths/randomization/rndTypes.ts

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