math-exercises 2.2.7 → 2.2.8

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inequalityToInterval = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const intervals_1 = require("../../../../math/sets/intervals/intervals");
+const inequationNode_1 = require("../../../../tree/nodes/inequations/inequationNode");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getIntervalToInequalityQuestion = () => {
+    const interval = intervals_1.IntervalConstructor.random();
+    const inequalityString = interval.toInequality();
+    const answer = inequalityString;
+    const instruction = `Soit $x \\in ${interval.toTex()}$. Traduire cette appartenance en une inégalité.`;
+    const question = {
+        answer,
+        instruction: instruction,
+        keys: ["x", "inf", "sup", "geq", "leq", "infty"],
+        answerFormat: "tex",
+        identifiers: {
+            intervalMin: interval.min === -Infinity ? "-infty" : interval.min,
+            intervalMax: interval.max === Infinity ? "infty" : interval.max,
+            intervalClosure: interval.closure,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, intervalClosure, intervalMax, intervalMin }) => {
+    const switchInclusion = (symbol) => {
+        if (symbol === "\\le")
+            return "<";
+        if (symbol === "<")
+            return "\\le";
+        if (symbol === ">")
+            return "\\ge";
+        return ">";
+    };
+    const reverseInequality = (symbol) => {
+        if (symbol === "\\le")
+            return "\\ge";
+        if (symbol === "<")
+            return ">";
+        if (symbol === ">")
+            return "<";
+        return "\\le";
+    };
+    const min = intervalMin === "-infty" ? -Infinity : intervalMin;
+    const max = intervalMax === "infty" ? Infinity : intervalMax;
+    const interval = new intervals_1.Interval(min.toTree(), max.toTree(), intervalClosure);
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const xNode = new variableNode_1.VariableNode("x");
+    let wrongIneqs = [];
+    if (interval.min === -Infinity) {
+        wrongIneqs = [
+            new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.max)], switchInclusion(interval.rightInequalitySymbol)),
+            new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.max)], reverseInequality(switchInclusion(interval.rightInequalitySymbol))),
+            new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.max)], reverseInequality(interval.rightInequalitySymbol)),
+        ];
+    }
+    else if (interval.max === Infinity) {
+        wrongIneqs = [
+            new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.min)], switchInclusion(interval.leftInequalitySymbol)),
+            new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.min)], reverseInequality(switchInclusion(interval.leftInequalitySymbol))),
+            new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.min)], interval.leftInequalitySymbol),
+        ];
+    }
+    else {
+        wrongIneqs = [
+            new inequationNode_1.InequationNode([new numberNode_1.NumberNode(interval.min), xNode, new numberNode_1.NumberNode(interval.max)], [
+                switchInclusion(interval.leftInequalitySymbol),
+                interval.rightInequalitySymbol,
+            ]),
+            new inequationNode_1.InequationNode([new numberNode_1.NumberNode(interval.min), xNode, new numberNode_1.NumberNode(interval.max)], [
+                interval.leftInequalitySymbol,
+                switchInclusion(interval.rightInequalitySymbol),
+            ]),
+            new inequationNode_1.InequationNode([new numberNode_1.NumberNode(interval.min), xNode, new numberNode_1.NumberNode(interval.max)], [
+                switchInclusion(interval.leftInequalitySymbol),
+                switchInclusion(interval.rightInequalitySymbol),
+            ]),
+        ];
+    }
+    wrongIneqs.forEach((ineq) => {
+        (0, exercise_1.addWrongProp)(propositions, ineq.toTex());
+    });
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { intervalClosure, intervalMax, intervalMin }) => {
+    const min = intervalMin === "-infty" ? -Infinity : intervalMin;
+    const max = intervalMax === "infty" ? Infinity : intervalMax;
+    const interval = new intervals_1.Interval(min.toTree(), max.toTree(), intervalClosure).toTree();
+    const inequality = interval.toInequality();
+    const answer = inequality;
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.inequalityToInterval = {
+    id: "intervalToInequality",
+    connector: "=",
+    label: "Traduire un intervalle en inégalité",
+    levels: ["2ndPro", "2nde", "CAP", "1reESM"],
+    isSingleStep: true,
+    sections: ["Ensembles et intervalles"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getIntervalToInequalityQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/squareRoots/squareRootsSum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squareRootsSum.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvB,CAAC;AA+EF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}
+{"version":3,"file":"squareRootsSum.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvB,CAAC;AA8EF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}

package/lib/exercises/math/squareRoots/squareRootsSum.js

@@ -62,7 +62,6 @@ const isAnswerValid = (ans, { answer, a, b, c, d, y, x, z }) => {
     }
     const tree = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(coeff), new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(b))).simplify();
     const texs = tree.toAllValidTexs();
-    console.log("vea SumSQRT answer: ", answer, "texs : ", texs);
     return texs.includes(ans);
 };
 exports.squareRootsSum = {

package/lib/exercises/pc/chemicalElements/findAtomEntitiesNumberFromMass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findAtomEntitiesNumberFromMass.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/findAtomEntitiesNumberFromMass.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAAE,WAAW,EAAE,MAAM,mDAAmD,CAAC;AAMhF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,WAAW,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAuEF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAahE,CAAC"}
+{"version":3,"file":"findAtomEntitiesNumberFromMass.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/findAtomEntitiesNumberFromMass.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAAE,WAAW,EAAE,MAAM,mDAAmD,CAAC;AAMhF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,WAAW,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAsEF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAahE,CAAC"}

package/lib/exercises/pc/chemicalElements/findAtomEntitiesNumberFromMass.js

@@ -18,7 +18,6 @@ const getFindAtomEntitiesNumberFromMassQuestion = () => {
     const sampleMassMeasure = new measure_1.Measure(sampleMass, 0, massUnits_1.MassUnit.kg);
     const atomMass = atoms_1.nucleonMass.value.times(atom.masseAtomique).toSignificant(2);
     const entitiesNumber = sampleMassMeasure.divide(atomMass).toSignificant(2);
-    console.log("entitiesNumber", entitiesNumber);
     const instruction = `Un échantillon a une masse $m = ${sampleMassMeasure.toTex()}$ ${(0, requiresApostropheBefore_1.requiresApostropheBefore)(atom.name) ? "d'" : "de "}${atom.name}. La masse d'un atome ${(0, requiresApostropheBefore_1.requiresApostropheBefore)(atom.name) ? "d'" : "de "}${atom.name} est de $${atomMass.toTex({ scientific: 2 })}$.
   Déterminer le nombre d'atomes ${(0, requiresApostropheBefore_1.requiresApostropheBefore)(atom.name) ? "d'" : "de "}${atom.name} composant l'échantillon.`;
     const question = {

package/lib/exercises/pc/energy/energyTransfer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"energyTransfer.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/energyTransfer.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAiEF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}
+{"version":3,"file":"energyTransfer.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/energyTransfer.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAgEF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}

package/lib/exercises/pc/energy/energyTransfer.js

@@ -49,7 +49,6 @@ const isAnswerValid = (ans, { answer, energy }) => {
     const validanswer2 = energy.toTree().toAllValidTexs();
     let latexs = [];
     latexs.push(validanswer1, ...validanswer2);
-    console.log(latexs);
     return latexs.includes(ans);
 };
 exports.energyTransfer = {

package/lib/exercises/pc/forces/gravitationalAttractionObjectHeight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gravitationalAttractionObjectHeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/gravitationalAttractionObjectHeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiIF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,WAAW,CAerE,CAAC"}
+{"version":3,"file":"gravitationalAttractionObjectHeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/gravitationalAttractionObjectHeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgIF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,WAAW,CAerE,CAAC"}

package/lib/exercises/pc/forces/gravitationalAttractionObjectHeight.js

@@ -112,7 +112,6 @@ const isAnswerValid = (ans, { answer, h }) => {
         validanswer2.toSignificant(2).toTex({ hideUnit: true }),
         validanswer3.toSignificant(2).toTex({ hideUnit: true }),
     ];
-    console.log(latexs);
     return latexs.includes(ans);
 };
 exports.gravitationalAttractionObjectHeight = {

package/lib/exercises/pc/mecanicalWaves/elongationReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elongationReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/mecanicalWaves/elongationReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA6FF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}
+{"version":3,"file":"elongationReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/mecanicalWaves/elongationReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA4FF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}

package/lib/exercises/pc/mecanicalWaves/elongationReading.js

@@ -54,7 +54,6 @@ const isAnswerValid = (ans, { answer, amplitude, period }) => {
     const node = new multiplyNode_1.MultiplyNode(amplitude.toTree(), new cosNode_1.CosNode(new multiplyNode_1.MultiplyNode(frac, new variableNode_1.VariableNode("t"))));
     const equal = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y\\left(t\\right)"), node);
     const texs = equal.toAllValidTexs({ allowRawRightChildAsSolution: true });
-    console.log(texs);
     return texs.includes(ans);
 };
 exports.elongationReading = {

package/lib/index.d.ts

@@ -93,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<{
@@ -1247,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;
@@ -1273,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[];
@@ -1283,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/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/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":"AAQA,eAAO,MAAM,UAAU,YAEtB,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,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
-const toSeparatedThousands_1 = require("./utils/numberPrototype/toSeparatedThousands");
+const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
 const playground = () => {
-    console.log((0, toSeparatedThousands_1.toSeperatedThousands)("12345,6789"));
+    console.log(infiniteNode_1.MinusInfinityNode.evaluate({}));
 };
 exports.playground = playground;

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/package.json

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