math-exercises 2.0.2 → 2.0.4

package/lib/math/numbers/reals/real.js

@@ -1,114 +1,114 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SquareRoot = exports.SquareRootConstructor = exports.Real = exports.RealConstructor = void 0;
-const isSquare_1 = require("../../../math/utils/arithmetic/isSquare");
-const primeFactors_1 = require("../../../math/utils/arithmetic/primeFactors");
-const randint_1 = require("../../../math/utils/random/randint");
-const sqrtNode_1 = require("../../../tree/nodes/functions/sqrtNode");
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
-const piNode_1 = require("../../../tree/nodes/numbers/piNode");
-const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
-const diceFlip_1 = require("../../../utils/diceFlip");
-const random_1 = require("../../../utils/random");
-const integer_1 = require("../integer/integer");
-const primes_1 = require("../integer/primes");
-const nombre_1 = require("../nombre");
-class RealConstructor {
-    static random() {
-        const dice = (0, diceFlip_1.diceFlip)(2);
-        switch (dice) {
-            case 0:
-                return new Real(Math.PI, "\\pi");
-            case 1:
-                return SquareRootConstructor.randomIrreductible();
-        }
-        return new Real(Math.PI, "\\pi");
-    }
-}
-exports.RealConstructor = RealConstructor;
-class Real {
-    constructor(value, tex) {
-        this.value = value;
-        this.tex = tex;
-        this.type = nombre_1.NumberType.Real;
-    }
-    toTree() {
-        if (this.tex === "\\pi")
-            return piNode_1.PiNode;
-        return new numberNode_1.NumberNode(this.value);
-    }
-}
-exports.Real = Real;
-class SquareRootConstructor {
-    /**
-     * @returns simplifiable square root type sqrt(c)=a*sqrt(b)
-     */
-    static randomSimplifiable({ allowPerfectSquare = false, maxSquare = 11, }) {
-        const a = (0, randint_1.randint)(2, maxSquare);
-        let b;
-        let bMin = allowPerfectSquare ? 1 : 2;
-        do {
-            b = (0, randint_1.randint)(bMin, maxSquare);
-        } while (b % (a * a) === 0 || (0, isSquare_1.isSquare)(b));
-        return new SquareRoot(a * a * b);
-    }
-    static randomIrreductible(max = 15) {
-        const a = (0, random_1.random)(primes_1.primes.filter((p) => p < max));
-        return new SquareRoot(a);
-    }
-}
-exports.SquareRootConstructor = SquareRootConstructor;
-class SquareRoot extends Real {
-    constructor(operand) {
-        super(Math.sqrt(operand), `\\sqrt{${operand}}`);
-        this.operand = operand;
-    }
-    isSimplifiable() {
-        if (this.operand === 0 || this.operand === 1)
-            return true;
-        const [a, b] = this.getSimplifiedCoeffs();
-        return a !== 1;
-    }
-    getSimplifiedCoeffs() {
-        if (this.operand === 0)
-            return [1, 0];
-        const factors = (0, primeFactors_1.primeFactors)(this.operand);
-        // finds primes with even exponents
-        const multiples = [1];
-        for (let i = 0; i < factors.length - 1; i++) {
-            if (factors[i] === factors[i + 1]) {
-                multiples.push(factors[i]);
-                factors.splice(i, 2);
-                i--;
-            }
-        }
-        const outsideSqrt = multiples.reduce((x, y) => x * y);
-        const insideSqrt = factors.length === 0 ? 1 : factors.reduce((x, y) => x * y);
-        return [outsideSqrt, insideSqrt];
-    }
-    simplify() {
-        if (this.operand === 0)
-            return new integer_1.Integer(0);
-        if (this.operand === 1)
-            return new integer_1.Integer(1);
-        const [outsideSqrt, insideSqrt] = this.getSimplifiedCoeffs();
-        const simplified = insideSqrt !== 1
-            ? new Real(outsideSqrt * Math.sqrt(insideSqrt), `${outsideSqrt === 1 ? "" : `${outsideSqrt}`}\\sqrt{${insideSqrt}}`)
-            : new Real(outsideSqrt, outsideSqrt + "");
-        simplified.toTree = () => {
-            return insideSqrt !== 1
-                ? outsideSqrt === 1
-                    ? new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(insideSqrt))
-                    : new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(outsideSqrt), new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(insideSqrt)))
-                : new numberNode_1.NumberNode(outsideSqrt);
-        };
-        return simplified;
-    }
-    toTex() {
-        return this.tex;
-    }
-    toTree() {
-        return new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(this.operand));
-    }
-}
-exports.SquareRoot = SquareRoot;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SquareRoot = exports.SquareRootConstructor = exports.Real = exports.RealConstructor = void 0;
+const isSquare_1 = require("../../../math/utils/arithmetic/isSquare");
+const primeFactors_1 = require("../../../math/utils/arithmetic/primeFactors");
+const randint_1 = require("../../../math/utils/random/randint");
+const sqrtNode_1 = require("../../../tree/nodes/functions/sqrtNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const piNode_1 = require("../../../tree/nodes/numbers/piNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const diceFlip_1 = require("../../../utils/diceFlip");
+const random_1 = require("../../../utils/random");
+const integer_1 = require("../integer/integer");
+const primes_1 = require("../integer/primes");
+const nombre_1 = require("../nombre");
+class RealConstructor {
+    static random() {
+        const dice = (0, diceFlip_1.diceFlip)(2);
+        switch (dice) {
+            case 0:
+                return new Real(Math.PI, "\\pi");
+            case 1:
+                return SquareRootConstructor.randomIrreductible();
+        }
+        return new Real(Math.PI, "\\pi");
+    }
+}
+exports.RealConstructor = RealConstructor;
+class Real {
+    constructor(value, tex) {
+        this.value = value;
+        this.tex = tex;
+        this.type = nombre_1.NumberType.Real;
+    }
+    toTree() {
+        if (this.tex === "\\pi")
+            return piNode_1.PiNode;
+        return new numberNode_1.NumberNode(this.value);
+    }
+}
+exports.Real = Real;
+class SquareRootConstructor {
+    /**
+     * @returns simplifiable square root type sqrt(c)=a*sqrt(b)
+     */
+    static randomSimplifiable({ allowPerfectSquare = false, maxSquare = 11, }) {
+        const a = (0, randint_1.randint)(2, maxSquare);
+        let b;
+        let bMin = allowPerfectSquare ? 1 : 2;
+        do {
+            b = (0, randint_1.randint)(bMin, maxSquare);
+        } while (b % (a * a) === 0 || (0, isSquare_1.isSquare)(b));
+        return new SquareRoot(a * a * b);
+    }
+    static randomIrreductible(max = 15) {
+        const a = (0, random_1.random)(primes_1.primes.filter((p) => p < max));
+        return new SquareRoot(a);
+    }
+}
+exports.SquareRootConstructor = SquareRootConstructor;
+class SquareRoot extends Real {
+    constructor(operand) {
+        super(Math.sqrt(operand), `\\sqrt{${operand}}`);
+        this.operand = operand;
+    }
+    isSimplifiable() {
+        if (this.operand === 0 || this.operand === 1)
+            return true;
+        const [a, b] = this.getSimplifiedCoeffs();
+        return a !== 1;
+    }
+    getSimplifiedCoeffs() {
+        if (this.operand === 0)
+            return [1, 0];
+        const factors = (0, primeFactors_1.primeFactors)(this.operand);
+        // finds primes with even exponents
+        const multiples = [1];
+        for (let i = 0; i < factors.length - 1; i++) {
+            if (factors[i] === factors[i + 1]) {
+                multiples.push(factors[i]);
+                factors.splice(i, 2);
+                i--;
+            }
+        }
+        const outsideSqrt = multiples.reduce((x, y) => x * y);
+        const insideSqrt = factors.length === 0 ? 1 : factors.reduce((x, y) => x * y);
+        return [outsideSqrt, insideSqrt];
+    }
+    simplify() {
+        if (this.operand === 0)
+            return new integer_1.Integer(0);
+        if (this.operand === 1)
+            return new integer_1.Integer(1);
+        const [outsideSqrt, insideSqrt] = this.getSimplifiedCoeffs();
+        const simplified = insideSqrt !== 1
+            ? new Real(outsideSqrt * Math.sqrt(insideSqrt), `${outsideSqrt === 1 ? "" : `${outsideSqrt}`}\\sqrt{${insideSqrt}}`)
+            : new Real(outsideSqrt, outsideSqrt + "");
+        simplified.toTree = () => {
+            return insideSqrt !== 1
+                ? outsideSqrt === 1
+                    ? new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(insideSqrt))
+                    : new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(outsideSqrt), new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(insideSqrt)))
+                : new numberNode_1.NumberNode(outsideSqrt);
+        };
+        return simplified;
+    }
+    toTex() {
+        return this.tex;
+    }
+    toTree() {
+        return new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(this.operand));
+    }
+}
+exports.SquareRoot = SquareRoot;

package/lib/math/polynomials/affine.d.ts

@@ -1,16 +1,16 @@
-import { Nombre } from '../numbers/nombre';
-import { MathSet } from '../sets/mathSet';
-import { Polynomial } from './polynomial';
-export declare abstract class AffineConstructor {
-    static random(domainA?: MathSet, domainB?: MathSet): Affine;
-    static differentRandoms(nb: number, domainA?: MathSet, domainB?: MathSet): Affine[];
-}
-export declare class Affine extends Polynomial {
-    a: number;
-    b: number;
-    variable: string;
-    constructor(a: number, b: number, variable?: string);
-    getRoot(): Nombre;
-    toString(): string;
-}
+import { Nombre } from '../numbers/nombre';
+import { MathSet } from '../sets/mathSet';
+import { Polynomial } from './polynomial';
+export declare abstract class AffineConstructor {
+    static random(domainA?: MathSet, domainB?: MathSet): Affine;
+    static differentRandoms(nb: number, domainA?: MathSet, domainB?: MathSet): Affine[];
+}
+export declare class Affine extends Polynomial {
+    a: number;
+    b: number;
+    variable: string;
+    constructor(a: number, b: number, variable?: string);
+    getRoot(): Nombre;
+    toString(): string;
+}
 //# sourceMappingURL=affine.d.ts.map

package/lib/math/polynomials/affine.js

@@ -1,44 +1,44 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Affine = exports.AffineConstructor = void 0;
-const integer_1 = require("../numbers/integer/integer");
-const rational_1 = require("../numbers/rationals/rational");
-const discreteSet_1 = require("../sets/discreteSet");
-const intervals_1 = require("../sets/intervals/intervals");
-const polynomial_1 = require("./polynomial");
-class AffineConstructor {
-    static random(domainA = new intervals_1.Interval('[[-10; 10]]').difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)])), domainB = new intervals_1.Interval('[[-10; 10]]')) {
-        const a = domainA.getRandomElement();
-        const b = domainB.getRandomElement();
-        if (a === null || b === null)
-            throw Error('received null in AffineConstructor');
-        return new Affine(a.value, b.value);
-    }
-    static differentRandoms(nb, domainA = new intervals_1.Interval('[[-10; 10]]').difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)])), domainB = new intervals_1.Interval('[[-10; 10]]')) {
-        const res = [];
-        for (let i = 0; i < nb; i++) {
-            let aff;
-            do {
-                aff = AffineConstructor.random(domainA, domainB);
-            } while (res.some((affine) => affine.equals(aff)));
-            res.push(aff);
-        }
-        return res;
-    }
-}
-exports.AffineConstructor = AffineConstructor;
-class Affine extends polynomial_1.Polynomial {
-    constructor(a, b, variable = 'x') {
-        super([b, a], variable);
-        this.a = a;
-        this.b = b;
-        this.variable = variable;
-    }
-    getRoot() {
-        return new rational_1.Rational(-this.b, this.a).simplify();
-    }
-    toString() {
-        return super.toTex();
-    }
-}
-exports.Affine = Affine;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Affine = exports.AffineConstructor = void 0;
+const integer_1 = require("../numbers/integer/integer");
+const rational_1 = require("../numbers/rationals/rational");
+const discreteSet_1 = require("../sets/discreteSet");
+const intervals_1 = require("../sets/intervals/intervals");
+const polynomial_1 = require("./polynomial");
+class AffineConstructor {
+    static random(domainA = new intervals_1.Interval('[[-10; 10]]').difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)])), domainB = new intervals_1.Interval('[[-10; 10]]')) {
+        const a = domainA.getRandomElement();
+        const b = domainB.getRandomElement();
+        if (a === null || b === null)
+            throw Error('received null in AffineConstructor');
+        return new Affine(a.value, b.value);
+    }
+    static differentRandoms(nb, domainA = new intervals_1.Interval('[[-10; 10]]').difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)])), domainB = new intervals_1.Interval('[[-10; 10]]')) {
+        const res = [];
+        for (let i = 0; i < nb; i++) {
+            let aff;
+            do {
+                aff = AffineConstructor.random(domainA, domainB);
+            } while (res.some((affine) => affine.equals(aff)));
+            res.push(aff);
+        }
+        return res;
+    }
+}
+exports.AffineConstructor = AffineConstructor;
+class Affine extends polynomial_1.Polynomial {
+    constructor(a, b, variable = 'x') {
+        super([b, a], variable);
+        this.a = a;
+        this.b = b;
+        this.variable = variable;
+    }
+    getRoot() {
+        return new rational_1.Rational(-this.b, this.a).simplify();
+    }
+    toString() {
+        return super.toTex();
+    }
+}
+exports.Affine = Affine;

package/lib/math/polynomials/monom.d.ts

@@ -1,5 +1,5 @@
-import { Polynomial } from './polynomial';
-export declare class Monom extends Polynomial {
-    constructor(degree: number, coeff: number, variable?: string);
-}
+import { Polynomial } from './polynomial';
+export declare class Monom extends Polynomial {
+    constructor(degree: number, coeff: number, variable?: string);
+}
 //# sourceMappingURL=monom.d.ts.map

package/lib/math/polynomials/monom.js

@@ -1,14 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Monom = void 0;
-const polynomial_1 = require("./polynomial");
-class Monom extends polynomial_1.Polynomial {
-    constructor(degree, coeff, variable = 'x') {
-        const coeffs = [];
-        for (let i = 0; i < degree; i++)
-            coeffs.push(0);
-        coeffs.push(coeff);
-        super(coeffs, variable);
-    }
-}
-exports.Monom = Monom;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Monom = void 0;
+const polynomial_1 = require("./polynomial");
+class Monom extends polynomial_1.Polynomial {
+    constructor(degree, coeff, variable = 'x') {
+        const coeffs = [];
+        for (let i = 0; i < degree; i++)
+            coeffs.push(0);
+        coeffs.push(coeff);
+        super(coeffs, variable);
+    }
+}
+exports.Monom = Monom;

package/lib/math/polynomials/polynomial.d.ts

@@ -1,46 +1,46 @@
-import { Node, NodeOptions } from "../../tree/nodes/node";
-import { NumberNode } from "../../tree/nodes/numbers/numberNode";
-export declare abstract class PolynomialConstructor {
-    static randomWithOrder(order: number, variable?: string): Polynomial;
-    static random(maxOrder: number, variable?: string): Polynomial;
-    /**
-     *
-     * @param maxOrder included
-     * @param length
-     * @param variable
-     * @returns
-     */
-    static randomWithLength(maxOrder: number, length: number, variable?: string): Polynomial;
-    static randomWithLengthAndSameSigns(maxOrder: number, length: number, variable?: string): Polynomial;
-    static randomNoFI(maxOrder: number, to: "+\\infty" | "-\\infty", length?: number, variable?: string): Polynomial;
-}
-export declare class Polynomial {
-    degree: number;
-    variable: string;
-    /**
-     * coefficients[i] est le coeff de x^i
-     */
-    coefficients: number[];
-    /**
-     *
-     * @param coefficients coefficients[i] est le coeff de x^i
-     * @param variable
-     */
-    constructor(coefficients: number[], variable?: string);
-    equals(P: Polynomial): boolean;
-    getRoots(): number[];
-    add(P: Polynomial | number): Polynomial;
-    times(nb: number): Polynomial;
-    multiply(Q: Polynomial): Polynomial;
-    scalarDivide(n: number): Polynomial;
-    opposite(): Polynomial;
-    derivate(): Polynomial;
-    integrateToNode(opts?: NodeOptions): Node;
-    calculate(x: number): number;
-    getLimit(to: "+\\infty" | "-\\infty"): string;
-    getLimitNode(to: "+\\infty" | "-\\infty"): NumberNode | import("../../tree/nodes/numbers/constantNode").ConstantNode;
-    toTree(opts?: NodeOptions): Node;
-    toTex(): string;
-    toString(): string;
-}
+import { Node, NodeOptions } from "../../tree/nodes/node";
+import { NumberNode } from "../../tree/nodes/numbers/numberNode";
+export declare abstract class PolynomialConstructor {
+    static randomWithOrder(order: number, variable?: string): Polynomial;
+    static random(maxOrder: number, variable?: string): Polynomial;
+    /**
+     *
+     * @param maxOrder included
+     * @param length
+     * @param variable
+     * @returns
+     */
+    static randomWithLength(maxOrder: number, length: number, variable?: string): Polynomial;
+    static randomWithLengthAndSameSigns(maxOrder: number, length: number, variable?: string): Polynomial;
+    static randomNoFI(maxOrder: number, to: "+\\infty" | "-\\infty", length?: number, variable?: string): Polynomial;
+}
+export declare class Polynomial {
+    degree: number;
+    variable: string;
+    /**
+     * coefficients[i] est le coeff de x^i
+     */
+    coefficients: number[];
+    /**
+     *
+     * @param coefficients coefficients[i] est le coeff de x^i
+     * @param variable
+     */
+    constructor(coefficients: number[], variable?: string);
+    equals(P: Polynomial): boolean;
+    getRoots(): number[];
+    add(P: Polynomial | number): Polynomial;
+    times(nb: number): Polynomial;
+    multiply(Q: Polynomial): Polynomial;
+    scalarDivide(n: number): Polynomial;
+    opposite(): Polynomial;
+    derivate(): Polynomial;
+    integrateToNode(opts?: NodeOptions): Node;
+    calculate(x: number): number;
+    getLimit(to: "+\\infty" | "-\\infty"): string;
+    getLimitNode(to: "+\\infty" | "-\\infty"): NumberNode | import("../../tree/nodes/numbers/constantNode").ConstantNode;
+    toTree(opts?: NodeOptions): Node;
+    toTex(): string;
+    toString(): string;
+}
 //# sourceMappingURL=polynomial.d.ts.map