math-exercises 2.2.6 → 2.2.8

package/lib/index.d.ts

@@ -7,6 +7,7 @@ declare global {
     }
     interface String {
         toTree: () => AlgebraicNode;
+        unfrenchify: () => number;
     }
 }
 /**
@@ -92,6 +93,20 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     num: number;
     denum: number;
     leadingPart: number;
+}> | import("./exercises/exercise").Exercise<{
+    denom: number;
+    num1: number;
+    num2: number;
+}> | import("./exercises/exercise").Exercise<{
+    num1: number;
+    num2: number;
+    denom1: number;
+    denom2: number;
+}> | import("./exercises/exercise").Exercise<{
+    num1: number;
+    num2: number;
+    denom1: number;
+    denom2: number;
 }> | import("./exercises/exercise").Exercise<{
     numbers: number[];
 }> | import("./exercises/exercise").Exercise<{
@@ -105,6 +120,10 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     rand: number;
     a: number;
     b: number;
+}> | import("./exercises/exercise").Exercise<{
+    numbers: number[];
+}> | import("./exercises/exercise").Exercise<{
+    numbers: number[];
 }> | import("./exercises/exercise").Exercise<{
     type: number;
     a: number;
@@ -594,6 +613,38 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     ineqSymbol: import("./math/inequations/inequation").InegalitySymbols;
     intervals: {
         a: number;
+        /**
+         * TODO
+         * Décimal : permettre facilement -0.xxx
+         * Tree shaking export
+         *
+         * VEA:
+         *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
+         *      ->> faire le meme delire que pour les power mais pour les opposite ?
+         *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
+         *  -> faire des nodes pour les Ensembles de nombre
+         *
+         * !-> choses pour lesquelles la v1 ne marchera pas :
+         *  !-- fractions non réduites
+         *  !-- nbs décimaux avec des 0
+         *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
+         * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
+         *
+         * Passer les sqrtNode en tree-iable
+         *
+         *
+         *
+         * !!!à fix :
+         * ! fraction réductible
+         * ! 0,20 au lieu de 0,2
+         * ! moins partout dans fraction
+         * !puissances négatives vers inverse fraction
+         * ! simplification du ln
+         * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
+         *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
+         * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
+        
+        */
         b: number;
         closure: import("./tree/nodes/sets/closure").ClosureType;
     }[];
@@ -800,7 +851,10 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     correctA: number;
     correctB: number;
-}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
+}> | import("./exercises/exercise").Exercise<{
+    x: number;
+    y: number;
+}> | import("./exercises/exercise").Exercise<{
     coin: boolean;
     radius: number;
     diametre: number;
@@ -999,7 +1053,6 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     rate: number;
     nbMois: number;
 }> | import("./exercises/exercise").Exercise<{
-    isFromEvolutionToCM: boolean;
     evolution: number;
 }> | import("./exercises/exercise").Exercise<{
     evolutions: string[];
@@ -1016,6 +1069,8 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     total: number;
     lefties: number;
 }> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
+    evolution: number;
+}> | import("./exercises/exercise").Exercise<{
     int: number;
     power: number;
 }> | import("./exercises/exercise").Exercise<{
@@ -1206,6 +1261,11 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     rank2: number;
     value2: number;
     rankAsked: number;
+}> | import("./exercises/exercise").Exercise<{
+    firstRank: number;
+    firstTerm: number;
+    reason: number;
+    askedRank: number;
 }> | import("./exercises/exercise").Exercise<{
     firstValue: number;
     reason: number;
@@ -1232,6 +1292,14 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     reason: number;
     firstValue: number;
     firstRank: number;
+}> | import("./exercises/exercise").Exercise<{
+    firstRank: number;
+    firstTerm: number;
+    reason: number;
+    askedRank: number;
+}> | import("./exercises/exercise").Exercise<{
+    sequence: number[];
+    reason: number;
 }> | import("./exercises/exercise").Exercise<{
     rank: number;
     coeffs: number[];
@@ -1242,9 +1310,8 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     u0: number;
     coeffs: number[];
 }> | import("./exercises/exercise").Exercise<{
-    isIntervalToInequality: boolean;
-    intervalMin: number;
-    intervalMax: number;
+    intervalMin: string | number;
+    intervalMax: string | number;
     intervalClosure: import("./tree/nodes/sets/closure").ClosureType;
 }> | import("./exercises/exercise").Exercise<{
     int1Min: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/index.js

@@ -31,6 +31,9 @@ const PCExercises = __importStar(require("./exercises/pc"));
 const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
 const toScientific_1 = require("./utils/numberPrototype/toScientific");
 const variableNode_1 = require("./tree/nodes/variables/variableNode");
+String.prototype.unfrenchify = function () {
+    return Number(this.valueOf().replace(",", "."));
+};
 String.prototype.toTree = function () {
     return new variableNode_1.VariableNode(this.valueOf());
 };

package/lib/math/geometry/line.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAQjE,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;gBACjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAkBxC,YAAY,CAAC,KAAK,EAAE,KAAK;IAUzB,QAAQ,CAAC,KAAK,EAAE,KAAK;IAarB,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAc5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;CAsBlC"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAQjE,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;gBACjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAkBxC,YAAY,CAAC,KAAK,EAAE,KAAK;IASzB,QAAQ,CAAC,KAAK,EAAE,KAAK;IAarB,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;CAsBlC"}

package/lib/math/geometry/line.js

@@ -40,7 +40,6 @@ class Line {
     }
     getParallele(point) {
         if (this.isVertical) {
-            console.log(this.pointA.toTexWithCoords(), this.pointB.toTexWithCoords());
             throw Error("Parallel vertical lines not implemented");
         }
         const x = new addNode_1.AddNode(point.x, new numberNode_1.NumberNode(1)).simplify();
@@ -61,7 +60,6 @@ class Line {
         }
         const x = new numberNode_1.NumberNode((0, randint_1.randint)(-10, 10));
         const y = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, x), this.b).simplify();
-        console.log(y.toTex(), this.a.toTex(), x.toTex(), this.b?.toTex());
         return new point_1.Point(name ?? "A", x, y);
     }
     getCartesianEquation() {

package/lib/math/geometry/spaceVector.d.ts

@@ -14,6 +14,7 @@ export declare class SpaceVector {
     z: AlgebraicNode;
     constructor(name: string, x: AlgebraicNode, y: AlgebraicNode, z: AlgebraicNode);
     toTex(): string;
+    toCoordsTex(): string;
     toInlineCoordsTex(): string;
     toTexWithCoords(): string;
     isColinear(v: SpaceVector): boolean;

package/lib/math/geometry/spaceVector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spaceVector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spaceVector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAQvD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,WAAW;IAQnE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,WAAW;IAY1D,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,UAAO,GAAG,WAAW,EAAE;CAW1E;AAED,qBAAa,WAAW;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IASlB,KAAK,IAAI,MAAM;IAIf,iBAAiB,IAAI,MAAM;IAK3B,eAAe,IAAI,MAAM;IAMzB,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAGnC,WAAW,CAAC,CAAC,EAAE,WAAW,GAAG,aAAa;IAI1C,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAQrC,aAAa,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAInC,GAAG,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAShC,OAAO,IAAI,aAAa;IAYxB,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM;IAQjD,MAAM,CAAC,CAAC,EAAE,WAAW;CAGtB"}
+{"version":3,"file":"spaceVector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spaceVector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAQvD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,WAAW;IAQnE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,WAAW;IAY1D,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,UAAO,GAAG,WAAW,EAAE;CAW1E;AAED,qBAAa,WAAW;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IASlB,KAAK,IAAI,MAAM;IAIf,WAAW,IAAI,MAAM;IAGrB,iBAAiB,IAAI,MAAM;IAK3B,eAAe,IAAI,MAAM;IAMzB,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAGnC,WAAW,CAAC,CAAC,EAAE,WAAW,GAAG,aAAa;IAI1C,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAQrC,aAAa,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAInC,GAAG,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAShC,OAAO,IAAI,aAAa;IAYxB,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM;IAQjD,MAAM,CAAC,CAAC,EAAE,WAAW;CAGtB"}

package/lib/math/geometry/spaceVector.js

@@ -47,6 +47,9 @@ class SpaceVector {
     toTex() {
         return `\\overrightarrow{${this.name}}`;
     }
+    toCoordsTex() {
+        return `\\begin{pmatrix}${this.x.toTex()} \\\\ ${this.y.toTex()} \\\\ ${this.z.toTex()} \\end{pmatrix}`;
+    }
     toInlineCoordsTex() {
         return `\\left(${this.x.simplify().toTex()};${this.y
             .simplify()

package/lib/math/polynomials/trinom.js

@@ -179,14 +179,14 @@ class Trinom extends polynomial_1.Polynomial {
         const alpha = this.getAlpha();
         let square;
         if (alpha !== 0) {
-            square = new powerNode_1.SquareNode(new addNode_1.AddNode(new variableNode_1.VariableNode(this.variable), new oppositeNode_1.OppositeNode(this.getAlphaNode())));
+            square = new powerNode_1.SquareNode(new addNode_1.AddNode(new variableNode_1.VariableNode(this.variable), new oppositeNode_1.OppositeNode(this.getAlphaNode()).simplify()));
         }
         else {
             square = new powerNode_1.SquareNode(new variableNode_1.VariableNode(this.variable));
         }
         const beta = this.getBeta();
         return beta !== 0
-            ? new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(this.a), square), new numberNode_1.NumberNode(this.getBeta()))
+            ? new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(this.a), square), this.getBetaNode())
             : new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(this.a), square);
     }
     getSommet() {

package/lib/pc/constants/molecularChemistry/reaction.js

@@ -324,7 +324,9 @@ class ReactionConstructor {
             for (const reactionSpecies of reaction) {
                 const foundMolecule = molecule_1.molecules.find((molecule) => molecule.formula === reactionSpecies.species);
                 if (!foundMolecule) {
-                    console.log(`La species '${reactionSpecies.species}' n'a pas été trouvée dans molecules.`);
+                    // console.log(
+                    //   `La species '${reactionSpecies.species}' n'a pas été trouvée dans molecules.`,
+                    // );
                 }
             }
         }

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,UAAU,YAgBtB,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,UAAU,YAEtB,CAAC"}

package/lib/playground.js

@@ -1,20 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
-const affine_1 = require("./math/polynomials/affine");
-const randTupleInt_1 = require("./math/utils/random/randTupleInt");
-const addNode_1 = require("./tree/nodes/operators/addNode");
-const multiplyNode_1 = require("./tree/nodes/operators/multiplyNode");
-const random_1 = require("./utils/random");
-const shuffle_1 = require("./utils/shuffle");
+const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
 const playground = () => {
-    const affines = affine_1.AffineConstructor.differentRandoms(3);
-    const permut = [
-        (0, shuffle_1.shuffle)([affines[0], affines[1]]),
-        (0, shuffle_1.shuffle)([affines[0], affines[2]]),
-    ];
-    const operation = (0, random_1.random)(["add", "substract"]);
-    const statementTree = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(permut[0][0].toTree(), permut[0][1].toTree()), new multiplyNode_1.MultiplyNode(permut[1][0].toTree(), permut[1][1].toTree()));
-    console.log((0, randTupleInt_1.distinctRandTupleInt)(3, 2, { from: 1, to: 10 }));
+    console.log(infiniteNode_1.MinusInfinityNode.evaluate({}));
 };
 exports.playground = playground;

package/lib/server.d.ts

@@ -7,6 +7,7 @@ declare global {
     }
     interface String {
         toTree: () => AlgebraicNode;
+        unfrenchify: () => number;
     }
 }
 //# sourceMappingURL=server.d.ts.map

package/lib/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAuC3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;IACD,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;KAC7B;CACF"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAuC3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;IACD,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,WAAW,EAAE,MAAM,MAAM,CAAC;KAC3B;CACF"}

package/lib/server.js

@@ -45,6 +45,9 @@ const allExercises = [...mathExercises, ...pcExercises];
 String.prototype.toTree = function () {
     return new variableNode_1.VariableNode(this.valueOf());
 };
+String.prototype.unfrenchify = function () {
+    return Number(this.valueOf().replace(",", "."));
+};
 Number.prototype.toTree = function () {
     const value = this.valueOf();
     if (value === Infinity)
@@ -65,7 +68,7 @@ const runServer = () => {
     app.use((0, cors_1.default)());
     console.log("math exos", mathExercises.length);
     console.log("math hints", mathExercises.filter((exo) => exo.hasHintAndCorrection).length);
-    console.log("pc exos", pcExercises.length);
+    console.log("pc exos", `${pcExercises.length}`);
     (0, playground_1.playground)();
     app.get("/", (req, res) => {
         res.json(allExercises);

package/lib/tree/nodes/sets/closure.d.ts

@@ -7,6 +7,8 @@ export declare enum ClosureType {
 export declare abstract class Closure {
     static random(): ClosureType;
     static reverse(closure: ClosureType): ClosureType;
+    static leftReverse(closure: ClosureType): ClosureType;
+    static rightReverse(closure: ClosureType): ClosureType;
     static switch(closure: ClosureType): ClosureType;
     static fromBrackets(left: "[" | "]", right: "]" | "["): ClosureType;
 }

package/lib/tree/nodes/sets/closure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"closure.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/closure.ts"],"names":[],"mappings":"AAEA,oBAAY,WAAW;IACrB,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;CACH;AAED,8BAAsB,OAAO;IAC3B,MAAM,CAAC,MAAM;IAcb,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,WAAW;IAYnC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,WAAW;IAYlC,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG;CAOtD"}
+{"version":3,"file":"closure.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/closure.ts"],"names":[],"mappings":"AAEA,oBAAY,WAAW;IACrB,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;CACH;AAED,8BAAsB,OAAO;IAC3B,MAAM,CAAC,MAAM;IAcb,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,WAAW;IAYnC,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW;IAYvC,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,WAAW;IAYxC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,WAAW;IAYlC,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG;CAOtD"}

package/lib/tree/nodes/sets/closure.js

@@ -36,6 +36,30 @@ class Closure {
                 return ClosureType.FO;
         }
     }
+    static leftReverse(closure) {
+        switch (closure) {
+            case ClosureType.FF:
+                return ClosureType.OF;
+            case ClosureType.OO:
+                return ClosureType.FO;
+            case ClosureType.FO:
+                return ClosureType.OO;
+            case ClosureType.OF:
+                return ClosureType.FF;
+        }
+    }
+    static rightReverse(closure) {
+        switch (closure) {
+            case ClosureType.OF:
+                return ClosureType.OO;
+            case ClosureType.OO:
+                return ClosureType.OF;
+            case ClosureType.FO:
+                return ClosureType.FF;
+            case ClosureType.FF:
+                return ClosureType.FO;
+        }
+    }
     static switch(closure) {
         switch (closure) {
             case ClosureType.FF:

package/lib/tree/nodes/sets/intervalNode.d.ts

@@ -18,6 +18,9 @@ export declare class IntervalNode implements SetNode {
     toMathString(): string;
     toMathjs(): string;
     toReversedClosure(): IntervalNode;
+    toLeftReversedClosure(): IntervalNode;
+    toRightReversedClosure(): IntervalNode;
+    toRandomDifferentClosure(): IntervalNode;
     toComplement(): IntervalNode | UnionIntervalNode;
     toTex(): string;
 }

package/lib/tree/nodes/sets/intervalNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/intervalNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAQtD,OAAO,EAAW,WAAW,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,WAAW,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,OAAO;IAC1C,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,OAAO,EAAE,WAAW,CAAC;IACrB,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBACI,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW;IAStE,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW;IAMjC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAoBpC,YAAY,CAAC,WAAW,CAAC,EAAE,IAAI;IA4B/B,YAAY;IAIZ,QAAQ;IAIR,iBAAiB;IAIjB,YAAY;IAkCZ,KAAK;CAWN"}
+{"version":3,"file":"intervalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/intervalNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAQtD,OAAO,EAAW,WAAW,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,WAAW,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,OAAO;IAC1C,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,OAAO,EAAE,WAAW,CAAC;IACrB,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBACI,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW;IAStE,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW;IAMjC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAoBpC,YAAY,CAAC,WAAW,CAAC,EAAE,IAAI;IA4B/B,YAAY;IAIZ,QAAQ;IAIR,iBAAiB;IAGjB,qBAAqB;IAGrB,sBAAsB;IAGtB,wBAAwB;IAWxB,YAAY;IAkCZ,KAAK;CAWN"}

package/lib/tree/nodes/sets/intervalNode.js

@@ -63,6 +63,19 @@ class IntervalNode {
     toReversedClosure() {
         return new IntervalNode(this.a, this.b, closure_1.Closure.reverse(this.closure));
     }
+    toLeftReversedClosure() {
+        return new IntervalNode(this.a, this.b, closure_1.Closure.leftReverse(this.closure));
+    }
+    toRightReversedClosure() {
+        return new IntervalNode(this.a, this.b, closure_1.Closure.rightReverse(this.closure));
+    }
+    toRandomDifferentClosure() {
+        return new IntervalNode(this.a, this.b, Math.random() < 0.3
+            ? closure_1.Closure.leftReverse(this.closure)
+            : Math.random() < 0.3
+                ? closure_1.Closure.reverse(this.closure)
+                : closure_1.Closure.rightReverse(this.closure));
+    }
     toComplement() {
         if ((0, infiniteNode_1.isInfiniteNode)(this.a) && (0, infiniteNode_1.isInfiniteNode)(this.b))
             return this;

package/lib/tree/parsers/latexParser.js

@@ -101,7 +101,7 @@ const buildTree = (tokens) => {
         if (token === ")" || token === "}")
             currentDepth--;
     }
-    console.log("depthed: ", depthedTokens);
+    // console.log("depthed: ", depthedTokens);
     while (true) {
         if (maxDepth === 0) {
             const tree = buildTreeForSameDepthTokens(depthedTokens.map((el) => el.token));
@@ -119,13 +119,13 @@ const buildTree = (tokens) => {
                 token: tree,
                 depth: token.depth - 1,
             });
-            console.log(`depthed after iter ${i}`, depthedTokens);
+            // console.log(`depthed after iter ${i}`, depthedTokens);
         }
         maxDepth--;
     }
 };
 const buildTreeForSameDepthTokens = (tokens) => {
-    console.log("start: ", tokens);
+    // console.log("start: ", tokens);
     let tempTokens = [];
     for (let i = 0; i < tokens.length; i++) {
         const token = tokens[i];
@@ -148,7 +148,7 @@ const buildTreeForSameDepthTokens = (tokens) => {
         else
             throw Error(`token not implemented: ${token}`);
     }
-    console.log("after parses : ", tempTokens);
+    // console.log("after parses : ", tempTokens);
     //1 build les fct
     for (let i = 0; i < tempTokens.length; i++) {
         if (typeof tempTokens[i] !== "string")
@@ -210,7 +210,7 @@ const buildTreeForSameDepthTokens = (tokens) => {
             }
         }
     }
-    console.log("after fcts: ", tempTokens);
+    // console.log("after fcts: ", tempTokens);
     //3 build les *
     let currentProduct;
     let currentProductStartIndex;
@@ -251,7 +251,7 @@ const buildTreeForSameDepthTokens = (tokens) => {
     }
     //4 build les +
     let currentAdd;
-    console.log("beforeAdd", tempTokens);
+    // console.log("beforeAdd", tempTokens);
     for (let i = 0; i < tempTokens.length; i++) {
         const token = tempTokens[i];
         if (!currentAdd) {

package/lib/utils/numberPrototype/toSeparatedThousands.d.ts

@@ -0,0 +1,2 @@
+export declare const toSeperatedThousands: (t: string) => string;
+//# sourceMappingURL=toSeparatedThousands.d.ts.map

package/lib/utils/numberPrototype/toSeparatedThousands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSeparatedThousands.d.ts","sourceRoot":"","sources":["../../../src/utils/numberPrototype/toSeparatedThousands.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,MAAO,MAAM,WAQ7C,CAAC"}

package/lib/utils/numberPrototype/toSeparatedThousands.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSeperatedThousands = void 0;
+const toSeperatedThousands = (t) => {
+    const n = t.unfrenchify();
+    if (isNaN(n))
+        throw Error("NaN passed to toSeperatedThousands");
+    const [intPart, fracPart] = t.split(",");
+    return (intPart.replace(/\B(?=(\d{3})+(?!\d))/g, "\\ ") +
+        (fracPart !== undefined ? "," + fracPart : ""));
+};
+exports.toSeperatedThousands = toSeperatedThousands;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.2.6",
+  "version": "2.2.8",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [