math-exercises 1.3.54 → 1.3.56

package/lib/math/sequences/sequence.d.ts

@@ -1,23 +1,23 @@
-import { Node } from '../../tree/nodes/node';
-import { Integer } from '../numbers/integer/integer';
-declare enum SequenceType {
-    arithmetic = 0,
-    geometric = 1,
-    other = 2
-}
-export declare class Sequence {
-    type: SequenceType;
-    firstRank: Integer;
-    firstTerm: Node;
-    recurrenceFormula?: string;
-    explicitFormula?: string;
-    constructor({ type, recurrenceFormula, explicitFormula, firstRank, firstTerm, }: {
-        type: SequenceType;
-        recurrenceFormula?: string;
-        explicitFormula?: string;
-        firstRank: Integer;
-        firstTerm: Node;
-    });
-}
-export {};
+import { Node } from '../../tree/nodes/node';
+import { Integer } from '../numbers/integer/integer';
+declare enum SequenceType {
+    arithmetic = 0,
+    geometric = 1,
+    other = 2
+}
+export declare class Sequence {
+    type: SequenceType;
+    firstRank: Integer;
+    firstTerm: Node;
+    recurrenceFormula?: string;
+    explicitFormula?: string;
+    constructor({ type, recurrenceFormula, explicitFormula, firstRank, firstTerm, }: {
+        type: SequenceType;
+        recurrenceFormula?: string;
+        explicitFormula?: string;
+        firstRank: Integer;
+        firstTerm: Node;
+    });
+}
+export {};
 //# sourceMappingURL=sequence.d.ts.map

package/lib/math/sequences/sequence.js

@@ -1,21 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sequence = void 0;
-const integer_1 = require("../numbers/integer/integer");
-var SequenceType;
-(function (SequenceType) {
-    SequenceType[SequenceType["arithmetic"] = 0] = "arithmetic";
-    SequenceType[SequenceType["geometric"] = 1] = "geometric";
-    SequenceType[SequenceType["other"] = 2] = "other";
-})(SequenceType || (SequenceType = {}));
-class Sequence {
-    constructor({ type, recurrenceFormula, explicitFormula, firstRank, firstTerm, }) {
-        this.firstRank = new integer_1.Integer(0);
-        this.type = type;
-        this.firstTerm = firstTerm;
-        this.recurrenceFormula = recurrenceFormula;
-        this.explicitFormula = explicitFormula;
-        this.firstRank = firstRank;
-    }
-}
-exports.Sequence = Sequence;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sequence = void 0;
+const integer_1 = require("../numbers/integer/integer");
+var SequenceType;
+(function (SequenceType) {
+    SequenceType[SequenceType["arithmetic"] = 0] = "arithmetic";
+    SequenceType[SequenceType["geometric"] = 1] = "geometric";
+    SequenceType[SequenceType["other"] = 2] = "other";
+})(SequenceType || (SequenceType = {}));
+class Sequence {
+    constructor({ type, recurrenceFormula, explicitFormula, firstRank, firstTerm, }) {
+        this.firstRank = new integer_1.Integer(0);
+        this.type = type;
+        this.firstTerm = firstTerm;
+        this.recurrenceFormula = recurrenceFormula;
+        this.explicitFormula = explicitFormula;
+        this.firstRank = firstRank;
+    }
+}
+exports.Sequence = Sequence;

package/lib/math/sets/discreteSet.d.ts

@@ -1,11 +1,11 @@
-import { Nombre } from '../numbers/nombre';
-import { MathSetInterface } from './mathSetInterface';
-export declare class DiscreteSet implements MathSetInterface {
-    elements: Nombre[];
-    tex: string;
-    constructor(elements: Nombre[]);
-    toTex(): string;
-    includes(el: Nombre): boolean;
-    getRandomElement(): Nombre;
-}
+import { Nombre } from '../numbers/nombre';
+import { MathSetInterface } from './mathSetInterface';
+export declare class DiscreteSet implements MathSetInterface {
+    elements: Nombre[];
+    tex: string;
+    constructor(elements: Nombre[]);
+    toTex(): string;
+    includes(el: Nombre): boolean;
+    getRandomElement(): Nombre;
+}
 //# sourceMappingURL=discreteSet.d.ts.map

package/lib/math/sets/discreteSet.js

@@ -1,28 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiscreteSet = void 0;
-const random_1 = require("../../utils/random");
-class DiscreteSet {
-    constructor(elements) {
-        this.elements = Array.from(new Set(elements));
-        let tex = '\\{';
-        this.elements.forEach((el, index) => {
-            tex += el.tex;
-            if (index < this.elements.length - 1)
-                tex += ';';
-            else
-                tex += '\\}';
-        });
-        this.tex = tex;
-    }
-    toTex() {
-        return this.tex;
-    }
-    includes(el) {
-        return this.elements.some((nb) => nb.value === el.value && nb.tex === el.tex);
-    }
-    getRandomElement() {
-        return (0, random_1.random)(this.elements);
-    }
-}
-exports.DiscreteSet = DiscreteSet;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscreteSet = void 0;
+const random_1 = require("../../utils/random");
+class DiscreteSet {
+    constructor(elements) {
+        this.elements = Array.from(new Set(elements));
+        let tex = '\\{';
+        this.elements.forEach((el, index) => {
+            tex += el.tex;
+            if (index < this.elements.length - 1)
+                tex += ';';
+            else
+                tex += '\\}';
+        });
+        this.tex = tex;
+    }
+    toTex() {
+        return this.tex;
+    }
+    includes(el) {
+        return this.elements.some((nb) => nb.value === el.value && nb.tex === el.tex);
+    }
+    getRandomElement() {
+        return (0, random_1.random)(this.elements);
+    }
+}
+exports.DiscreteSet = DiscreteSet;

package/lib/math/sets/emptySet.js

@@ -1,6 +1,6 @@
-"use strict";
-// import { MathSetInterface } from "./mathSetInterface";
-// export abstract class EmptySet implements MathSetInterface {
-//   tex: string = "\\emptyset";
-//   getRandomElement = () => null;
-// }
+"use strict";
+// import { MathSetInterface } from "./mathSetInterface";
+// export abstract class EmptySet implements MathSetInterface {
+//   tex: string = "\\emptyset";
+//   getRandomElement = () => null;
+// }

package/lib/math/sets/intervals/intervals.d.ts

@@ -1,27 +1,27 @@
-import { Nombre, NumberType } from '../../../math/numbers/nombre';
-import { DiscreteSet } from '../discreteSet';
-import { MathSet } from '../mathSet';
-import { MathSetInterface } from '../mathSetInterface';
-declare enum BoundType {
-    OO = "]a;b[",
-    OF = "]a;b]",
-    FO = "[a;b[",
-    FF = "[a;b]"
-}
-export declare class Interval implements MathSetInterface {
-    min: number;
-    max: number;
-    boundType: BoundType;
-    type: NumberType;
-    tex: string;
-    /**
-     * [[a; b]] pour un interval d'integer;  [a;b] pour des réels
-     */
-    constructor(tex?: string);
-    exclude(nb: number): MathSet;
-    difference(set: DiscreteSet): MathSet;
-    toTex(): string;
-    getRandomElement(precision?: number): Nombre;
-}
-export {};
+import { Nombre, NumberType } from '../../../math/numbers/nombre';
+import { DiscreteSet } from '../discreteSet';
+import { MathSet } from '../mathSet';
+import { MathSetInterface } from '../mathSetInterface';
+declare enum BoundType {
+    OO = "]a;b[",
+    OF = "]a;b]",
+    FO = "[a;b[",
+    FF = "[a;b]"
+}
+export declare class Interval implements MathSetInterface {
+    min: number;
+    max: number;
+    boundType: BoundType;
+    type: NumberType;
+    tex: string;
+    /**
+     * [[a; b]] pour un interval d'integer;  [a;b] pour des réels
+     */
+    constructor(tex?: string);
+    exclude(nb: number): MathSet;
+    difference(set: DiscreteSet): MathSet;
+    toTex(): string;
+    getRandomElement(precision?: number): Nombre;
+}
+export {};
 //# sourceMappingURL=intervals.d.ts.map

package/lib/math/sets/intervals/intervals.js

@@ -1,104 +1,104 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Interval = void 0;
-const epsilon_1 = require("../../../math/numbers/epsilon");
-const integer_1 = require("../../../math/numbers/integer/integer");
-const nombre_1 = require("../../../math/numbers/nombre");
-const real_1 = require("../../../math/numbers/reals/real");
-const round_1 = require("../../../math/utils/round");
-const mathSet_1 = require("../mathSet");
-var BoundType;
-(function (BoundType) {
-    BoundType["OO"] = "]a;b[";
-    BoundType["OF"] = "]a;b]";
-    BoundType["FO"] = "[a;b[";
-    BoundType["FF"] = "[a;b]";
-})(BoundType || (BoundType = {}));
-class Interval {
-    /**
-     * [[a; b]] pour un interval d'integer;  [a;b] pour des réels
-     */
-    constructor(tex = '[-10; 10]') {
-        if (!tex.includes(';'))
-            throw Error('wrong interval format');
-        this.tex = tex;
-        const isInt = tex[1] === '[' || tex[1] === ']';
-        this.type = isInt ? nombre_1.NumberType.Integer : nombre_1.NumberType.Real;
-        const left = tex[0];
-        const right = tex[tex.length - 1];
-        const [a, b] = tex.slice(isInt ? 2 : 1, isInt ? tex.length - 2 : tex.length - 1).split(';');
-        switch (`${left}a;b${right}`) {
-            case '[a;b]':
-                this.boundType = BoundType.FF;
-                break;
-            case ']a;b[':
-                this.boundType = BoundType.OO;
-                break;
-            case '[a;b[':
-                this.boundType = BoundType.FO;
-                break;
-            case ']a;b]':
-                this.boundType = BoundType.OF;
-                break;
-            default:
-                throw console.error('wrong interval format');
-        }
-        function getBound(bound) {
-            return bound === '-\\infty'
-                ? Number.NEGATIVE_INFINITY
-                : bound === '+\\infty'
-                    ? Number.POSITIVE_INFINITY
-                    : Number(bound);
-        }
-        this.min = getBound(a);
-        this.max = getBound(b);
-    }
-    // union(interval: Interval): MathSet {
-    //[a,b] [c,d]
-    //si a=c return a, max(b,d)
-    //si si b = d return min(a,c), b
-    //si a=d return c,b sauf si  OXXO
-    //si b=c return a,d sauf si XOOX
-    //si c > b ou d < a alors union disjointe avec plus petit en 1er
-    //sinon return min(a,c), max(b,d)
-    //res = a
-    // return new MathSet();
-    // }
-    exclude(nb) {
-        const rand = () => {
-            let x;
-            do {
-                x = this.getRandomElement();
-            } while (x.value === nb);
-            return x;
-        };
-        return new mathSet_1.MathSet(this.toTex() + `\\{${nb}\\}`, rand);
-    }
-    difference(set) {
-        const rand = () => {
-            let x;
-            do {
-                x = this.getRandomElement();
-            } while (set.includes(x));
-            return x;
-        };
-        return new mathSet_1.MathSet(this.toTex() + `\\ ${set.toTex()}`, rand);
-    }
-    toTex() {
-        return this.tex;
-    }
-    getRandomElement(precision = this.type === nombre_1.NumberType.Integer ? 0 : 2) {
-        if (this.min === -Infinity || this.max === Infinity)
-            throw Error("Can't chose amongst infinity");
-        let min = this.boundType === BoundType.OO || this.boundType === BoundType.OF ? this.min + epsilon_1.EPSILON : this.min;
-        let max = this.boundType === BoundType.OO || this.boundType === BoundType.FO ? this.max - epsilon_1.EPSILON : this.max;
-        const value = (0, round_1.round)(min + Math.random() * (max - this.min), precision);
-        switch (this.type) {
-            case nombre_1.NumberType.Integer:
-                return new integer_1.Integer(value);
-            default:
-                return new real_1.Real(value, value.toString());
-        }
-    }
-}
-exports.Interval = Interval;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Interval = void 0;
+const epsilon_1 = require("../../../math/numbers/epsilon");
+const integer_1 = require("../../../math/numbers/integer/integer");
+const nombre_1 = require("../../../math/numbers/nombre");
+const real_1 = require("../../../math/numbers/reals/real");
+const round_1 = require("../../../math/utils/round");
+const mathSet_1 = require("../mathSet");
+var BoundType;
+(function (BoundType) {
+    BoundType["OO"] = "]a;b[";
+    BoundType["OF"] = "]a;b]";
+    BoundType["FO"] = "[a;b[";
+    BoundType["FF"] = "[a;b]";
+})(BoundType || (BoundType = {}));
+class Interval {
+    /**
+     * [[a; b]] pour un interval d'integer;  [a;b] pour des réels
+     */
+    constructor(tex = '[-10; 10]') {
+        if (!tex.includes(';'))
+            throw Error('wrong interval format');
+        this.tex = tex;
+        const isInt = tex[1] === '[' || tex[1] === ']';
+        this.type = isInt ? nombre_1.NumberType.Integer : nombre_1.NumberType.Real;
+        const left = tex[0];
+        const right = tex[tex.length - 1];
+        const [a, b] = tex.slice(isInt ? 2 : 1, isInt ? tex.length - 2 : tex.length - 1).split(';');
+        switch (`${left}a;b${right}`) {
+            case '[a;b]':
+                this.boundType = BoundType.FF;
+                break;
+            case ']a;b[':
+                this.boundType = BoundType.OO;
+                break;
+            case '[a;b[':
+                this.boundType = BoundType.FO;
+                break;
+            case ']a;b]':
+                this.boundType = BoundType.OF;
+                break;
+            default:
+                throw console.error('wrong interval format');
+        }
+        function getBound(bound) {
+            return bound === '-\\infty'
+                ? Number.NEGATIVE_INFINITY
+                : bound === '+\\infty'
+                    ? Number.POSITIVE_INFINITY
+                    : Number(bound);
+        }
+        this.min = getBound(a);
+        this.max = getBound(b);
+    }
+    // union(interval: Interval): MathSet {
+    //[a,b] [c,d]
+    //si a=c return a, max(b,d)
+    //si si b = d return min(a,c), b
+    //si a=d return c,b sauf si  OXXO
+    //si b=c return a,d sauf si XOOX
+    //si c > b ou d < a alors union disjointe avec plus petit en 1er
+    //sinon return min(a,c), max(b,d)
+    //res = a
+    // return new MathSet();
+    // }
+    exclude(nb) {
+        const rand = () => {
+            let x;
+            do {
+                x = this.getRandomElement();
+            } while (x.value === nb);
+            return x;
+        };
+        return new mathSet_1.MathSet(this.toTex() + `\\{${nb}\\}`, rand);
+    }
+    difference(set) {
+        const rand = () => {
+            let x;
+            do {
+                x = this.getRandomElement();
+            } while (set.includes(x));
+            return x;
+        };
+        return new mathSet_1.MathSet(this.toTex() + `\\ ${set.toTex()}`, rand);
+    }
+    toTex() {
+        return this.tex;
+    }
+    getRandomElement(precision = this.type === nombre_1.NumberType.Integer ? 0 : 2) {
+        if (this.min === -Infinity || this.max === Infinity)
+            throw Error("Can't chose amongst infinity");
+        let min = this.boundType === BoundType.OO || this.boundType === BoundType.OF ? this.min + epsilon_1.EPSILON : this.min;
+        let max = this.boundType === BoundType.OO || this.boundType === BoundType.FO ? this.max - epsilon_1.EPSILON : this.max;
+        const value = (0, round_1.round)(min + Math.random() * (max - this.min), precision);
+        switch (this.type) {
+            case nombre_1.NumberType.Integer:
+                return new integer_1.Integer(value);
+            default:
+                return new real_1.Real(value, value.toString());
+        }
+    }
+}
+exports.Interval = Interval;

package/lib/math/sets/mathSet.d.ts

@@ -1,8 +1,8 @@
-import { Nombre } from "../numbers/nombre";
-import { MathSetInterface } from "./mathSetInterface";
-export declare class MathSet implements MathSetInterface {
-    tex: string;
-    getRandomElement: () => Nombre;
-    constructor(tex: string, getRandomElement: () => Nombre);
-}
+import { Nombre } from "../numbers/nombre";
+import { MathSetInterface } from "./mathSetInterface";
+export declare class MathSet implements MathSetInterface {
+    tex: string;
+    getRandomElement: () => Nombre;
+    constructor(tex: string, getRandomElement: () => Nombre);
+}
 //# sourceMappingURL=mathSet.d.ts.map

package/lib/math/sets/mathSet.js

@@ -1,10 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MathSet = void 0;
-class MathSet {
-    constructor(tex, getRandomElement) {
-        this.tex = tex;
-        this.getRandomElement = getRandomElement;
-    }
-}
-exports.MathSet = MathSet;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathSet = void 0;
+class MathSet {
+    constructor(tex, getRandomElement) {
+        this.tex = tex;
+        this.getRandomElement = getRandomElement;
+    }
+}
+exports.MathSet = MathSet;

package/lib/math/sets/mathSetInterface.d.ts

@@ -1,6 +1,6 @@
-import { Nombre } from '../numbers/nombre';
-export interface MathSetInterface {
-    tex: string;
-    getRandomElement: () => Nombre;
-}
+import { Nombre } from '../numbers/nombre';
+export interface MathSetInterface {
+    tex: string;
+    getRandomElement: () => Nombre;
+}
 //# sourceMappingURL=mathSetInterface.d.ts.map

package/lib/math/sets/mathSetInterface.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/math/trigonometry/remarkableValue.d.ts

@@ -1,11 +1,11 @@
-import { Node } from '../../tree/nodes/node';
-export interface RemarkableValue {
-    angle: Node;
-    cos: Node;
-    sin: Node;
-}
-export declare abstract class RemarkableValueConstructor {
-    static mainInterval: () => RemarkableValue;
-    static simplifiable: () => RemarkableValue;
-}
+import { Node } from '../../tree/nodes/node';
+export interface RemarkableValue {
+    angle: Node;
+    cos: Node;
+    sin: Node;
+}
+export declare abstract class RemarkableValueConstructor {
+    static mainInterval: () => RemarkableValue;
+    static simplifiable: () => RemarkableValue;
+}
 //# sourceMappingURL=remarkableValue.d.ts.map

package/lib/math/trigonometry/remarkableValue.js

@@ -1,29 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RemarkableValueConstructor = void 0;
-const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
-const piNode_1 = require("../../tree/nodes/numbers/piNode");
-const addNode_1 = require("../../tree/nodes/operators/addNode");
-const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
-const simplify_1 = require("../../tree/parsers/simplify");
-const random_1 = require("../../utils/random");
-const randint_1 = require("../utils/random/randint");
-const remarkableValues_1 = require("./remarkableValues");
-class RemarkableValueConstructor {
-}
-exports.RemarkableValueConstructor = RemarkableValueConstructor;
-RemarkableValueConstructor.mainInterval = () => {
-    const randValue = (0, random_1.random)(remarkableValues_1.remarkableTrigoValues);
-    return randValue;
-    // return new RemarkableValue(randValue.angle, randValue.cos, randValue.sin);
-};
-RemarkableValueConstructor.simplifiable = () => {
-    const randValue = (0, random_1.random)(remarkableValues_1.remarkableTrigoValues);
-    const toAdd = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode((0, randint_1.randint)(-3, 4) * 2), piNode_1.PiNode);
-    const newAngle = (0, simplify_1.simplifyNode)(new addNode_1.AddNode(randValue.angle, toAdd));
-    return {
-        angle: newAngle,
-        cos: randValue.cos,
-        sin: randValue.sin,
-    };
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemarkableValueConstructor = void 0;
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const piNode_1 = require("../../tree/nodes/numbers/piNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const simplify_1 = require("../../tree/parsers/simplify");
+const random_1 = require("../../utils/random");
+const randint_1 = require("../utils/random/randint");
+const remarkableValues_1 = require("./remarkableValues");
+class RemarkableValueConstructor {
+}
+exports.RemarkableValueConstructor = RemarkableValueConstructor;
+RemarkableValueConstructor.mainInterval = () => {
+    const randValue = (0, random_1.random)(remarkableValues_1.remarkableTrigoValues);
+    return randValue;
+    // return new RemarkableValue(randValue.angle, randValue.cos, randValue.sin);
+};
+RemarkableValueConstructor.simplifiable = () => {
+    const randValue = (0, random_1.random)(remarkableValues_1.remarkableTrigoValues);
+    const toAdd = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode((0, randint_1.randint)(-3, 4) * 2), piNode_1.PiNode);
+    const newAngle = (0, simplify_1.simplifyNode)(new addNode_1.AddNode(randValue.angle, toAdd));
+    return {
+        angle: newAngle,
+        cos: randValue.cos,
+        sin: randValue.sin,
+    };
+};

package/lib/math/trigonometry/remarkableValues.d.ts

@@ -1,3 +1,3 @@
-import { RemarkableValue } from './remarkableValue';
-export declare const remarkableTrigoValues: RemarkableValue[];
+import { RemarkableValue } from './remarkableValue';
+export declare const remarkableTrigoValues: RemarkableValue[];
 //# sourceMappingURL=remarkableValues.d.ts.map