math-exercises 1.3.31 → 1.3.32

package/lib/math/numbers/integer/integer.d.ts

@@ -1,15 +1,15 @@
-import { Node } from '../../../tree/nodes/node';
-import { Nombre, NumberType } from '../nombre';
-export declare abstract class IntegerConstructor {
-    static random(nbOfDigits: number): number;
-}
-export declare class Integer implements Nombre {
-    value: number;
-    tex: string;
-    type: NumberType;
-    constructor(value: number, tex?: string);
-    toTree(): Node;
-    round(precision: number): Integer;
-    divide(nb: Nombre): Nombre;
-}
+import { Node } from '../../../tree/nodes/node';
+import { Nombre, NumberType } from '../nombre';
+export declare abstract class IntegerConstructor {
+    static random(nbOfDigits: number): number;
+}
+export declare class Integer implements Nombre {
+    value: number;
+    tex: string;
+    type: NumberType;
+    constructor(value: number, tex?: string);
+    toTree(): Node;
+    round(precision: number): Integer;
+    divide(nb: Nombre): Nombre;
+}
 //# sourceMappingURL=integer.d.ts.map

package/lib/math/numbers/integer/integer.js

@@ -1,68 +1,68 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Integer = exports.IntegerConstructor = void 0;
-const randint_1 = require("../../../math/utils/random/randint");
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
-const nombre_1 = require("../nombre");
-const rational_1 = require("../rationals/rational");
-class IntegerConstructor {
-    static random(nbOfDigits) {
-        return (0, randint_1.randint)(0, 10 ** nbOfDigits);
-    }
-}
-exports.IntegerConstructor = IntegerConstructor;
-class Integer {
-    constructor(value, tex) {
-        this.value = value;
-        this.tex = tex || value + '';
-        this.type = nombre_1.NumberType.Integer;
-    }
-    toTree() {
-        return new numberNode_1.NumberNode(this.value, this.tex);
-    }
-    round(precision) {
-        const intString = this.value + '';
-        if (precision >= intString.length || precision < 1)
-            throw Error("can't round to higher precision");
-        let newInt = '';
-        const shouldRoundUp = Number(intString[intString.length - precision]) > 4;
-        if (shouldRoundUp) {
-            for (let i = 0; i < precision; i++) {
-                newInt += '0';
-            }
-            let retenue = true;
-            let i = intString.length - precision - 1;
-            while (retenue) {
-                const nb = (Number(intString[i]) + 1) % 10;
-                newInt = '' + nb + newInt;
-                if (nb === 0) {
-                    i--;
-                }
-                else {
-                    retenue = false;
-                    for (let j = i - 1; j > -1; j--) {
-                        newInt = intString[j] + newInt;
-                    }
-                }
-            }
-        }
-        else {
-            for (let i = 0; i < intString.length; i++) {
-                newInt += i < intString.length - precision ? intString[i] : '0';
-            }
-        }
-        return new Integer(Number(newInt));
-    }
-    divide(nb) {
-        switch (nb.type) {
-            case nombre_1.NumberType.Integer:
-                return new rational_1.Rational(this.value, nb.value).simplify();
-            case nombre_1.NumberType.Rational:
-                const rational = nb;
-                return new rational_1.Rational(this.value * rational.denum, rational.num).simplify();
-            default:
-                throw Error('not implemented');
-        }
-    }
-}
-exports.Integer = Integer;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Integer = exports.IntegerConstructor = void 0;
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const nombre_1 = require("../nombre");
+const rational_1 = require("../rationals/rational");
+class IntegerConstructor {
+    static random(nbOfDigits) {
+        return (0, randint_1.randint)(0, 10 ** nbOfDigits);
+    }
+}
+exports.IntegerConstructor = IntegerConstructor;
+class Integer {
+    constructor(value, tex) {
+        this.value = value;
+        this.tex = tex || value + '';
+        this.type = nombre_1.NumberType.Integer;
+    }
+    toTree() {
+        return new numberNode_1.NumberNode(this.value, this.tex);
+    }
+    round(precision) {
+        const intString = this.value + '';
+        if (precision >= intString.length || precision < 1)
+            throw Error("can't round to higher precision");
+        let newInt = '';
+        const shouldRoundUp = Number(intString[intString.length - precision]) > 4;
+        if (shouldRoundUp) {
+            for (let i = 0; i < precision; i++) {
+                newInt += '0';
+            }
+            let retenue = true;
+            let i = intString.length - precision - 1;
+            while (retenue) {
+                const nb = (Number(intString[i]) + 1) % 10;
+                newInt = '' + nb + newInt;
+                if (nb === 0) {
+                    i--;
+                }
+                else {
+                    retenue = false;
+                    for (let j = i - 1; j > -1; j--) {
+                        newInt = intString[j] + newInt;
+                    }
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < intString.length; i++) {
+                newInt += i < intString.length - precision ? intString[i] : '0';
+            }
+        }
+        return new Integer(Number(newInt));
+    }
+    divide(nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer:
+                return new rational_1.Rational(this.value, nb.value).simplify();
+            case nombre_1.NumberType.Rational:
+                const rational = nb;
+                return new rational_1.Rational(this.value * rational.denum, rational.num).simplify();
+            default:
+                throw Error('not implemented');
+        }
+    }
+}
+exports.Integer = Integer;

package/lib/math/numbers/integer/power.d.ts

@@ -1,14 +1,14 @@
-import { Node } from '../../../tree/nodes/node';
-import { Nombre, NumberType } from '../nombre';
-export declare class Power implements Nombre {
-    value: number;
-    tex: string;
-    type: NumberType;
-    operand: number;
-    power: number;
-    constructor(a: number, b: number);
-    simplify(): Node;
-    toDecimalWriting(): Nombre;
-    toTree(): Node;
-}
+import { Node } from '../../../tree/nodes/node';
+import { Nombre, NumberType } from '../nombre';
+export declare class Power implements Nombre {
+    value: number;
+    tex: string;
+    type: NumberType;
+    operand: number;
+    power: number;
+    constructor(a: number, b: number);
+    simplify(): Node;
+    toDecimalWriting(): Nombre;
+    toTree(): Node;
+}
 //# sourceMappingURL=power.d.ts.map

package/lib/math/numbers/integer/power.js

@@ -1,52 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Power = void 0;
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
-const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
-const nombre_1 = require("../nombre");
-const integer_1 = require("./integer");
-class Power {
-    constructor(a, b) {
-        this.operand = a;
-        this.power = b;
-        this.value = Math.pow(a, b);
-        this.tex = `${a}^{${b}}`;
-        this.type = b < 0 ? nombre_1.NumberType.Rational : nombre_1.NumberType.Integer;
-    }
-    simplify() {
-        if (this.power === 0)
-            return new numberNode_1.NumberNode(1);
-        if (this.power === 1)
-            return new numberNode_1.NumberNode(this.operand);
-        if (this.operand === 1)
-            return new numberNode_1.NumberNode(1);
-        if (this.operand === 0)
-            return new numberNode_1.NumberNode(0);
-        if (this.operand === -1)
-            return new numberNode_1.NumberNode(this.power % 2 === 0 ? 1 : -1);
-        return this.toTree();
-    }
-    toDecimalWriting() {
-        if (this.operand !== 10)
-            throw Error('only implemented for powers of ten so far');
-        let s = '';
-        if (this.power > -1) {
-            s += '1';
-            for (let i = 0; i < this.power; i++) {
-                s += 0;
-            }
-        }
-        else {
-            s += '1';
-            for (let i = 1; i < Math.abs(this.power); i++) {
-                s = '0' + s;
-            }
-            s = '0.' + s;
-        }
-        return new integer_1.Integer(Number(s), s);
-    }
-    toTree() {
-        return new powerNode_1.PowerNode(new numberNode_1.NumberNode(this.operand), new numberNode_1.NumberNode(this.power));
-    }
-}
-exports.Power = Power;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Power = void 0;
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
+const nombre_1 = require("../nombre");
+const integer_1 = require("./integer");
+class Power {
+    constructor(a, b) {
+        this.operand = a;
+        this.power = b;
+        this.value = Math.pow(a, b);
+        this.tex = `${a}^{${b}}`;
+        this.type = b < 0 ? nombre_1.NumberType.Rational : nombre_1.NumberType.Integer;
+    }
+    simplify() {
+        if (this.power === 0)
+            return new numberNode_1.NumberNode(1);
+        if (this.power === 1)
+            return new numberNode_1.NumberNode(this.operand);
+        if (this.operand === 1)
+            return new numberNode_1.NumberNode(1);
+        if (this.operand === 0)
+            return new numberNode_1.NumberNode(0);
+        if (this.operand === -1)
+            return new numberNode_1.NumberNode(this.power % 2 === 0 ? 1 : -1);
+        return this.toTree();
+    }
+    toDecimalWriting() {
+        if (this.operand !== 10)
+            throw Error('only implemented for powers of ten so far');
+        let s = '';
+        if (this.power > -1) {
+            s += '1';
+            for (let i = 0; i < this.power; i++) {
+                s += 0;
+            }
+        }
+        else {
+            s += '1';
+            for (let i = 1; i < Math.abs(this.power); i++) {
+                s = '0' + s;
+            }
+            s = '0.' + s;
+        }
+        return new integer_1.Integer(Number(s), s);
+    }
+    toTree() {
+        return new powerNode_1.PowerNode(new numberNode_1.NumberNode(this.operand), new numberNode_1.NumberNode(this.power));
+    }
+}
+exports.Power = Power;

package/lib/math/numbers/nombre.d.ts

@@ -1,14 +1,14 @@
-import { Node } from '../../tree/nodes/node';
-export declare enum NumberType {
-    Integer = 0,
-    Decimal = 1,
-    Rational = 2,
-    Real = 3
-}
-export interface Nombre {
-    value: number;
-    tex: string;
-    type: NumberType;
-    toTree: () => Node;
-}
+import { Node } from '../../tree/nodes/node';
+export declare enum NumberType {
+    Integer = 0,
+    Decimal = 1,
+    Rational = 2,
+    Real = 3
+}
+export interface Nombre {
+    value: number;
+    tex: string;
+    type: NumberType;
+    toTree: () => Node;
+}
 //# sourceMappingURL=nombre.d.ts.map

package/lib/math/numbers/nombre.js

@@ -1,10 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NumberType = void 0;
-var NumberType;
-(function (NumberType) {
-    NumberType[NumberType["Integer"] = 0] = "Integer";
-    NumberType[NumberType["Decimal"] = 1] = "Decimal";
-    NumberType[NumberType["Rational"] = 2] = "Rational";
-    NumberType[NumberType["Real"] = 3] = "Real";
-})(NumberType = exports.NumberType || (exports.NumberType = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberType = void 0;
+var NumberType;
+(function (NumberType) {
+    NumberType[NumberType["Integer"] = 0] = "Integer";
+    NumberType[NumberType["Decimal"] = 1] = "Decimal";
+    NumberType[NumberType["Rational"] = 2] = "Rational";
+    NumberType[NumberType["Real"] = 3] = "Real";
+})(NumberType = exports.NumberType || (exports.NumberType = {}));

package/lib/math/numbers/rationals/rational.d.ts

@@ -1,26 +1,26 @@
-import { Node } from '../../../tree/nodes/node';
-import { Nombre, NumberType } from '../nombre';
-export declare abstract class RationalConstructor {
-    /**
-     * @param maxGcd max number by which the fraction is simplifiable
-     */
-    static randomSimplifiable(maxGcd?: number): Rational;
-    static randomIrreductible(max?: number): Rational;
-}
-export declare class Rational implements Nombre {
-    num: number;
-    denum: number;
-    tex: string;
-    value: number;
-    isSimplified: boolean;
-    type: NumberType;
-    constructor(numerator: number, denumerator: number);
-    toTex(): string;
-    add(nb: Nombre): Nombre;
-    multiply(nb: Nombre): Nombre;
-    divide(nb: Nombre): Nombre;
-    opposite(): Rational;
-    toTree(): Node;
-    simplify(): Nombre;
-}
+import { Node } from '../../../tree/nodes/node';
+import { Nombre, NumberType } from '../nombre';
+export declare abstract class RationalConstructor {
+    /**
+     * @param maxGcd max number by which the fraction is simplifiable
+     */
+    static randomSimplifiable(maxGcd?: number): Rational;
+    static randomIrreductible(max?: number): Rational;
+}
+export declare class Rational implements Nombre {
+    num: number;
+    denum: number;
+    tex: string;
+    value: number;
+    isSimplified: boolean;
+    type: NumberType;
+    constructor(numerator: number, denumerator: number);
+    toTex(): string;
+    add(nb: Nombre): Nombre;
+    multiply(nb: Nombre): Nombre;
+    divide(nb: Nombre): Nombre;
+    opposite(): Rational;
+    toTree(): Node;
+    simplify(): Nombre;
+}
 //# sourceMappingURL=rational.d.ts.map

package/lib/math/numbers/rationals/rational.js

@@ -1,113 +1,113 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Rational = exports.RationalConstructor = void 0;
-const coprimesOf_1 = require("../../../math/utils/arithmetic/coprimesOf");
-const gcd_1 = require("../../../math/utils/arithmetic/gcd");
-const lcd_1 = require("../../../math/utils/arithmetic/lcd");
-const randint_1 = require("../../../math/utils/random/randint");
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
-const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
-const random_1 = require("../../../utils/random");
-const shuffle_1 = require("../../../utils/shuffle");
-const integer_1 = require("../integer/integer");
-const nombre_1 = require("../nombre");
-class RationalConstructor {
-    /**
-     * @param maxGcd max number by which the fraction is simplifiable
-     */
-    static randomSimplifiable(maxGcd = 10) {
-        const gcd = (0, randint_1.randint)(2, maxGcd);
-        const max = (0, randint_1.randint)(3, 11);
-        const min = (0, random_1.random)((0, coprimesOf_1.coprimesOf)(max));
-        let [num, denum] = (0, shuffle_1.shuffle)([gcd * min, gcd * max]);
-        if (denum === gcd) {
-            //si 10/2 on transforme en 2/10
-            return new Rational(denum, num);
-        }
-        return new Rational(num, denum);
-    }
-    static randomIrreductible(max = 11) {
-        const a = (0, randint_1.randint)(2, max);
-        const b = (0, random_1.random)([...(0, coprimesOf_1.coprimesOf)(a), 1]);
-        if (b === 1)
-            return new Rational(b, a);
-        const [num, denum] = (0, shuffle_1.shuffle)([a, b]);
-        return new Rational(num, denum);
-    }
-}
-exports.RationalConstructor = RationalConstructor;
-class Rational {
-    constructor(numerator, denumerator) {
-        if (denumerator === 0)
-            throw Error('division by zero');
-        this.num = numerator;
-        this.denum = denumerator;
-        this.value = numerator / denumerator;
-        this.isSimplified = Math.abs((0, gcd_1.gcd)(numerator, denumerator)) === 1;
-        this.tex = `\\frac{${this.num}}{${this.denum}}`;
-        this.type = nombre_1.NumberType.Rational;
-    }
-    toTex() {
-        return `\\frac{${this.num}}{${this.denum}}`;
-    }
-    add(nb) {
-        switch (nb.type) {
-            case nombre_1.NumberType.Integer: {
-                const num = this.num + this.denum * nb.value;
-                return new Rational(num, this.denum).simplify();
-            }
-            case nombre_1.NumberType.Rational: {
-                const rational = nb;
-                const ppcm = (0, lcd_1.lcd)(rational.denum, this.denum);
-                const num = this.num * (ppcm / this.denum) + rational.num * (ppcm / rational.denum);
-                return new Rational(num, ppcm).simplify();
-            }
-        }
-        throw Error('not implemented yet');
-    }
-    multiply(nb) {
-        switch (nb.type) {
-            case nombre_1.NumberType.Integer: {
-                const num = this.num * nb.value;
-                const denum = this.denum;
-                return new Rational(num, denum).simplify();
-            }
-            case nombre_1.NumberType.Rational: {
-                const rational = nb;
-                const num = this.num * rational.num;
-                const denum = this.denum * rational.denum;
-                return new Rational(num, denum).simplify();
-            }
-        }
-        throw Error('not implemented yet');
-    }
-    divide(nb) {
-        switch (nb.type) {
-            case nombre_1.NumberType.Integer: {
-                const denum = this.denum * nb.value;
-                return new Rational(this.num, denum).simplify();
-            }
-            case nombre_1.NumberType.Rational: {
-                const rational = nb;
-                const num = this.num * rational.denum;
-                const denum = this.denum * rational.num;
-                return new Rational(num, denum).simplify();
-            }
-        }
-        throw Error('not implemented yet');
-    }
-    opposite() {
-        return new Rational(-this.num, this.denum);
-    }
-    toTree() {
-        return new fractionNode_1.FractionNode(new numberNode_1.NumberNode(this.num), new numberNode_1.NumberNode(this.denum));
-    }
-    simplify() {
-        const sign = (this.num > 0 && this.denum > 0) || (this.num < 0 && this.denum < 0) ? 1 : -1;
-        const div = Math.abs((0, gcd_1.gcd)(this.num, this.denum));
-        if (Math.abs(this.denum) === div)
-            return new integer_1.Integer(this.num / this.denum);
-        return new Rational((sign * Math.abs(this.num)) / div, Math.abs(this.denum) / div);
-    }
-}
-exports.Rational = Rational;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rational = exports.RationalConstructor = void 0;
+const coprimesOf_1 = require("../../../math/utils/arithmetic/coprimesOf");
+const gcd_1 = require("../../../math/utils/arithmetic/gcd");
+const lcd_1 = require("../../../math/utils/arithmetic/lcd");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const random_1 = require("../../../utils/random");
+const shuffle_1 = require("../../../utils/shuffle");
+const integer_1 = require("../integer/integer");
+const nombre_1 = require("../nombre");
+class RationalConstructor {
+    /**
+     * @param maxGcd max number by which the fraction is simplifiable
+     */
+    static randomSimplifiable(maxGcd = 10) {
+        const gcd = (0, randint_1.randint)(2, maxGcd);
+        const max = (0, randint_1.randint)(3, 11);
+        const min = (0, random_1.random)((0, coprimesOf_1.coprimesOf)(max));
+        let [num, denum] = (0, shuffle_1.shuffle)([gcd * min, gcd * max]);
+        if (denum === gcd) {
+            //si 10/2 on transforme en 2/10
+            return new Rational(denum, num);
+        }
+        return new Rational(num, denum);
+    }
+    static randomIrreductible(max = 11) {
+        const a = (0, randint_1.randint)(2, max);
+        const b = (0, random_1.random)([...(0, coprimesOf_1.coprimesOf)(a), 1]);
+        if (b === 1)
+            return new Rational(b, a);
+        const [num, denum] = (0, shuffle_1.shuffle)([a, b]);
+        return new Rational(num, denum);
+    }
+}
+exports.RationalConstructor = RationalConstructor;
+class Rational {
+    constructor(numerator, denumerator) {
+        if (denumerator === 0)
+            throw Error('division by zero');
+        this.num = numerator;
+        this.denum = denumerator;
+        this.value = numerator / denumerator;
+        this.isSimplified = Math.abs((0, gcd_1.gcd)(numerator, denumerator)) === 1;
+        this.tex = `\\frac{${this.num}}{${this.denum}}`;
+        this.type = nombre_1.NumberType.Rational;
+    }
+    toTex() {
+        return `\\frac{${this.num}}{${this.denum}}`;
+    }
+    add(nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer: {
+                const num = this.num + this.denum * nb.value;
+                return new Rational(num, this.denum).simplify();
+            }
+            case nombre_1.NumberType.Rational: {
+                const rational = nb;
+                const ppcm = (0, lcd_1.lcd)(rational.denum, this.denum);
+                const num = this.num * (ppcm / this.denum) + rational.num * (ppcm / rational.denum);
+                return new Rational(num, ppcm).simplify();
+            }
+        }
+        throw Error('not implemented yet');
+    }
+    multiply(nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer: {
+                const num = this.num * nb.value;
+                const denum = this.denum;
+                return new Rational(num, denum).simplify();
+            }
+            case nombre_1.NumberType.Rational: {
+                const rational = nb;
+                const num = this.num * rational.num;
+                const denum = this.denum * rational.denum;
+                return new Rational(num, denum).simplify();
+            }
+        }
+        throw Error('not implemented yet');
+    }
+    divide(nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer: {
+                const denum = this.denum * nb.value;
+                return new Rational(this.num, denum).simplify();
+            }
+            case nombre_1.NumberType.Rational: {
+                const rational = nb;
+                const num = this.num * rational.denum;
+                const denum = this.denum * rational.num;
+                return new Rational(num, denum).simplify();
+            }
+        }
+        throw Error('not implemented yet');
+    }
+    opposite() {
+        return new Rational(-this.num, this.denum);
+    }
+    toTree() {
+        return new fractionNode_1.FractionNode(new numberNode_1.NumberNode(this.num), new numberNode_1.NumberNode(this.denum));
+    }
+    simplify() {
+        const sign = (this.num > 0 && this.denum > 0) || (this.num < 0 && this.denum < 0) ? 1 : -1;
+        const div = Math.abs((0, gcd_1.gcd)(this.num, this.denum));
+        if (Math.abs(this.denum) === div)
+            return new integer_1.Integer(this.num / this.denum);
+        return new Rational((sign * Math.abs(this.num)) / div, Math.abs(this.denum) / div);
+    }
+}
+exports.Rational = Rational;

package/lib/math/numbers/reals/real.d.ts

@@ -1,10 +1,10 @@
-import { Node } from '../../../tree/nodes/node';
-import { Nombre, NumberType } from '../nombre';
-export declare class Real implements Nombre {
-    value: number;
-    tex: string;
-    type: NumberType;
-    constructor(value: number, tex: string);
-    toTree(): Node;
-}
+import { Node } from '../../../tree/nodes/node';
+import { Nombre, NumberType } from '../nombre';
+export declare class Real implements Nombre {
+    value: number;
+    tex: string;
+    type: NumberType;
+    constructor(value: number, tex: string);
+    toTree(): Node;
+}
 //# sourceMappingURL=real.d.ts.map