math-exercises 2.2.81 → 2.2.83

package/lib/exercises/math/matrices/matrixInversibilityDomain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matrixInversibilityDomain.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/matrices/matrixInversibilityDomain.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAyBlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA0FF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}
+{"version":3,"file":"matrixInversibilityDomain.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/matrices/matrixInversibilityDomain.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AA0BlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoGF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}

package/lib/exercises/math/matrices/matrixInversibilityDomain.js

@@ -17,6 +17,7 @@ const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
 const unionIntervalNode_1 = require("../../../tree/nodes/sets/unionIntervalNode");
 const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
 const latexParser_1 = require("../../../tree/parsers/latexParser");
+const unionIntervalParser_1 = require("../../../tree/parsers/unionIntervalParser");
 const intervalKeys_1 = require("../../utils/keys/intervalKeys");
 const getMatrixInversibilityDomainQuestion = () => {
     const elements = [[], []];
@@ -50,7 +51,9 @@ const getMatrixInversibilityDomainQuestion = () => {
             ]).toTex();
     const question = {
         answer,
-        instruction: `Soit $M = ${matrix.toTex()}$, où $x\\in \\mathbb{R}$. Sur quel ensemble la matrice $M$ est-elle inversible ?
+        instruction: `Soit $M = ${matrix.toTex()}$, où $x\\in \\mathbb{R}$. 
+
+Sur quel ensemble la matrice $M$ est-elle inversible ?
     `,
         keys: [...intervalKeys_1.intervalKeys, "reals", "varnothing"],
         answerFormat: "tex",
@@ -78,7 +81,17 @@ const getPropositions = (n, { answer, a, b, c, d }) => {
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    try {
+        if (answer === "\\mathbb{R}" || answer === "\\varnothing")
+            return ans === answer;
+        const parsed = (0, unionIntervalParser_1.unionIntervalParser)(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return false;
+    }
 };
 exports.matrixInversibilityDomain = {
     id: "matrixInversibilityDomain",

package/lib/exercises/math/probaStat/binomial/binomialInequation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"binomialInequation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/binomial/binomialInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,0BAA0B,CAAC;AAUlC,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAM1C,OAAO,EAEL,uBAAuB,EACxB,MAAM,oCAAoC,CAAC;AAK5C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,EAAE,uBAAuB,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAgKF,KAAK,OAAO,GAAG;IACb,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAgBF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuB7D,CAAC"}
+{"version":3,"file":"binomialInequation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/binomial/binomialInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,0BAA0B,CAAC;AASlC,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAM1C,OAAO,EAEL,uBAAuB,EACxB,MAAM,oCAAoC,CAAC;AAK5C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,EAAE,uBAAuB,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAgKF,KAAK,OAAO,GAAG;IACb,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAgBF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuB7D,CAAC"}

package/lib/exercises/math/python/pyForLoop1Exercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pyForLoop1Exercise.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pyForLoop1Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,cAAc,CAAC;CAC1B,CAAC;AAOF,KAAK,cAAc,GAAG;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ,CAAC;AA6KF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAaxD,CAAC"}
+{"version":3,"file":"pyForLoop1Exercise.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pyForLoop1Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,cAAc,CAAC;CAC1B,CAAC;AAOF,KAAK,cAAc,GAAG;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ,CAAC;AA6KF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAaxD,CAAC"}

package/lib/exercises/math/sequences/genericSequenceVariations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"genericSequenceVariations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/genericSequenceVariations.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAmDF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}
+{"version":3,"file":"genericSequenceVariations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/genericSequenceVariations.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAmDF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}

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

@@ -1,9 +1,7 @@
 import { Exercise } from "../../../../exercises/exercise";
-import { ClosureType } from "../../../../tree/nodes/sets/closure";
+import { IntervalNodeIdentifiers } from "../../../../tree/nodes/sets/intervalNode";
 type Identifiers = {
-    intervalMin: number | string;
-    intervalMax: number | string;
-    intervalClosure: ClosureType;
+    intervalIdentifiers: IntervalNodeIdentifiers;
 };
 export declare const inequalityToInterval: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/sets/intervals/inequalityToInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAO5D,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,eAAe,EAAE,WAAW,CAAC;CAC9B,CAAC;AAkFF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAQlC,OAAO,EAGL,uBAAuB,EACxB,MAAM,oCAAoC,CAAC;AAI5C,KAAK,WAAW,GAAG;IAIjB,mBAAmB,EAAE,uBAAuB,CAAC;CAC9C,CAAC;AAqFF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}

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

@@ -3,14 +3,31 @@ 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 infiniteNode_1 = require("../../../../tree/nodes/numbers/infiniteNode");
+const intervalNode_1 = require("../../../../tree/nodes/sets/intervalNode");
 const intervalParser_1 = require("../../../../tree/parsers/intervalParser");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
+const rebuildIdentifiers = (oldIds) => {
+    if (!!oldIds.intervalIdentifiers)
+        return oldIds;
+    const a = oldIds.intervalMin === "-infty" || oldIds.intervalMin === -Infinity
+        ? infiniteNode_1.MinusInfinityNode
+        : oldIds.intervalMin.toTree();
+    const b = oldIds.intervalMax === "infty" || oldIds.intervalMax === Infinity
+        ? infiniteNode_1.PlusInfinityNode
+        : oldIds.intervalMax.toTree();
+    const closure = oldIds.intervalClosure;
+    const interval = new intervalNode_1.IntervalNode(a, b, closure);
+    return { intervalIdentifiers: interval.toIdentifiers() };
+};
 const getInequalityToIntervalQuestion = () => {
-    const interval = intervals_1.IntervalConstructor.random();
-    const inequalityString = interval.toInequality();
+    const interval = intervalNode_1.IntervalNodeConstructor.random();
+    const inequality = interval.toInequality();
     const answer = `x\\in\\ ${interval.toTex()}`;
-    const instruction = `Soit $${inequalityString}$. Traduire cette inégalité en appartenance à un intervalle.`;
+    const instruction = `Soit $${inequality.toTex()}$. Traduire cette inégalité en appartenance à un intervalle.`;
+    const identifiers = {
+        intervalIdentifiers: interval.toIdentifiers(),
+    };
     const question = {
         answer,
         instruction: instruction,
@@ -27,34 +44,21 @@ const getInequalityToIntervalQuestion = () => {
             "infty",
         ],
         answerFormat: "tex",
-        identifiers: {
-            intervalMin: interval.min === -Infinity ? "-infty" : interval.min,
-            intervalMax: interval.max === Infinity ? "infty" : interval.max,
-            intervalClosure: interval.closure,
-        },
+        identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer, intervalClosure, intervalMax, intervalMin }) => {
-    const reverseBracket = (bracket) => {
-        return bracket === "[" ? "]" : "[";
-    };
-    const min = intervalMin === "-infty" ? -Infinity : intervalMin;
-    const max = intervalMax === "infty" ? Infinity : intervalMax;
-    const interval = new intervals_1.Interval(min.toTree(), max.toTree(), intervalClosure);
+const getPropositions = (n, { answer, intervalIdentifiers }) => {
+    const interval = intervalNode_1.IntervalNodeConstructor.fromIdentifiers(intervalIdentifiers);
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const wrongStatements = [
-        `x\\in\\ ${reverseBracket(interval.leftBracket)}\\ ${interval.insideToTex()}\\ ${interval.rightBracket}\\ `,
-        `x\\in\\ ${interval.leftBracket}\\ ${interval.insideToTex()}\\ ${reverseBracket(interval.rightBracket)}\\ `,
-        `x\\in\\ ${reverseBracket(interval.leftBracket)}\\ ${interval.insideToTex()}\\ ${reverseBracket(interval.rightBracket)}\\ `,
-    ];
-    wrongStatements.forEach((ineq) => {
-        (0, exercise_1.addWrongProp)(propositions, ineq);
-    });
+    (0, exercise_1.tryToAddWrongProp)(propositions, "x\\in\\ " + interval.toLeftReversedClosure().toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, "x\\in\\ " + interval.toRightReversedClosure().toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, "x\\in\\ " +
+        interval.toLeftReversedClosure().toRightReversedClosure().toTex());
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { intervalClosure, intervalMax, intervalMin, answer }) => {
+const isAnswerValid = (ans, { answer }) => {
     try {
         const parsed = (0, intervalParser_1.intervalParser)(ans.replaceAll("x\\in", ""));
         if (!parsed)
@@ -78,4 +82,5 @@ exports.inequalityToInterval = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    rebuildIdentifiers,
 };

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

@@ -1,9 +1,7 @@
 import { Exercise } from "../../../../exercises/exercise";
-import { ClosureType } from "../../../../tree/nodes/sets/closure";
+import { IntervalNodeIdentifiers } from "../../../../tree/nodes/sets/intervalNode";
 type Identifiers = {
-    intervalMin: number | string;
-    intervalMax: number | string;
-    intervalClosure: ClosureType;
+    intervalIdentifiers: IntervalNodeIdentifiers;
 };
 export declare const intervalToInequality: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/sets/intervals/intervalToInequality.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalToInequality.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalToInequality.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAK5D,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,eAAe,EAAE,WAAW,CAAC;CAC9B,CAAC;AAkIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"intervalToInequality.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalToInequality.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAWlC,OAAO,EAGL,uBAAuB,EACxB,MAAM,oCAAoC,CAAC;AAK5C,KAAK,WAAW,GAAG;IAIjB,mBAAmB,EAAE,uBAAuB,CAAC;CAC9C,CAAC;AAgFF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}

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

@@ -3,97 +3,60 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.intervalToInequality = 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 infiniteNode_1 = require("../../../../tree/nodes/numbers/infiniteNode");
+const intervalNode_1 = require("../../../../tree/nodes/sets/intervalNode");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
+const rebuildIdentifiers = (oldIds) => {
+    if (!!oldIds.intervalIdentifiers)
+        return oldIds;
+    const a = oldIds.intervalMin === "-infty" || oldIds.intervalMin === -Infinity
+        ? infiniteNode_1.MinusInfinityNode
+        : oldIds.intervalMin.toTree();
+    const b = oldIds.intervalMax === "infty" || oldIds.intervalMax === Infinity
+        ? infiniteNode_1.PlusInfinityNode
+        : oldIds.intervalMax.toTree();
+    const closure = oldIds.intervalClosure;
+    const interval = new intervalNode_1.IntervalNode(a, b, closure);
+    return { intervalIdentifiers: interval.toIdentifiers() };
+};
+const getInstruction = (identifiers) => {
+    const interval = intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.intervalIdentifiers);
+    return `Soit $x \\in ${interval.toTex()}$. Traduire cette appartenance en une inégalité.`;
+};
+const getAnswer = (identifiers) => {
+    const interval = intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.intervalIdentifiers);
+    const inequality = interval.toInequality();
+    const answer = inequality.toTex();
+    return answer;
+};
 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 interval = intervalNode_1.IntervalNodeConstructor.random();
+    const identifiers = {
+        intervalIdentifiers: interval.toIdentifiers(),
+    };
     const question = {
-        answer,
-        instruction: instruction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         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,
-        },
+        identifiers,
     };
     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 getPropositions = (n, { answer, intervalIdentifiers }) => {
+    const interval = intervalNode_1.IntervalNodeConstructor.fromIdentifiers(intervalIdentifiers);
     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());
-    });
+    const ineq = interval.toInequality();
+    (0, exercise_1.tryToAddWrongProp)(propositions, ineq.toSwicthedStrictness().toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, ineq.toSwitched().toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, ineq.toSwitched().toSwicthedStrictness().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 isAnswerValid = (ans, { answer, intervalIdentifiers }) => {
+    const interval = intervalNode_1.IntervalNodeConstructor.fromIdentifiers(intervalIdentifiers);
     const inequality = interval.toInequality();
-    const answer = inequality;
-    const texs = answer.toAllValidTexs();
+    const texs = inequality.toAllValidTexs();
     return texs.includes(ans);
 };
 exports.intervalToInequality = {
@@ -109,4 +72,5 @@ exports.intervalToInequality = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    rebuildIdentifiers,
 };

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

@@ -1,12 +1,8 @@
 import { Exercise } from "../../../../exercises/exercise";
-import { ClosureType } from "../../../../tree/nodes/sets/closure";
+import { IntervalNodeIdentifiers } from "../../../../tree/nodes/sets/intervalNode";
 type Identifiers = {
-    int1Min: number;
-    int1Max: number;
-    int1Closure: ClosureType;
-    int2Min: number;
-    int2Max: number;
-    int2Closure: ClosureType;
+    int1Identifiers: IntervalNodeIdentifiers;
+    int2Identifiers: IntervalNodeIdentifiers;
 };
 export declare const intervalsIntersection: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/sets/intervals/intervalsIntersection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalsIntersection.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalsIntersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAAW,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAQrE,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AA6EF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAevD,CAAC"}
+{"version":3,"file":"intervalsIntersection.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalsIntersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAYlC,OAAO,EAGL,uBAAuB,EAExB,MAAM,oCAAoC,CAAC;AAK5C,KAAK,WAAW,GAAG;IAOjB,eAAe,EAAE,uBAAuB,CAAC;IACzC,eAAe,EAAE,uBAAuB,CAAC;CAC1C,CAAC;AAqJF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}

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

@@ -3,17 +3,84 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.intervalsIntersection = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
-const intervals_1 = require("../../../../math/sets/intervals/intervals");
+const infiniteNode_1 = require("../../../../tree/nodes/numbers/infiniteNode");
 const discreteSetNode_1 = require("../../../../tree/nodes/sets/discreteSetNode");
 const intervalNode_1 = require("../../../../tree/nodes/sets/intervalNode");
+const discreteSetParser_1 = require("../../../../tree/parsers/discreteSetParser");
+const intervalParser_1 = require("../../../../tree/parsers/intervalParser");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
+const rebuildIdentifiers = (oldIds) => {
+    if (!!oldIds.int1Identifiers)
+        return oldIds;
+    const a1 = oldIds.int1Min === "-infty" || oldIds.int2Min === -Infinity
+        ? infiniteNode_1.MinusInfinityNode
+        : oldIds.int1Min.toTree();
+    const b1 = oldIds.int1Max === "infty" || oldIds.int1Max === Infinity
+        ? infiniteNode_1.PlusInfinityNode
+        : oldIds.int1Max.toTree();
+    const closure1 = oldIds.int1Closure;
+    const interval1 = new intervalNode_1.IntervalNode(a1, b1, closure1);
+    const a2 = oldIds.int2Min === "-infty" || oldIds.int2Min === -Infinity
+        ? infiniteNode_1.MinusInfinityNode
+        : oldIds.int2Min.toTree();
+    const b2 = oldIds.int2Max === "infty" || oldIds.int2Max === Infinity
+        ? infiniteNode_1.PlusInfinityNode
+        : oldIds.int2Max.toTree();
+    const closure2 = oldIds.int2Closure;
+    const interval2 = new intervalNode_1.IntervalNode(a2, b2, closure2);
+    return {
+        int1Identifiers: interval1.toIdentifiers(),
+        int2Identifiers: interval2.toIdentifiers(),
+    };
+};
+const getInstruction = (identifiers) => {
+    const [int1, int2] = [
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int1Identifiers),
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int2Identifiers),
+    ];
+    return `Soit $I = ${int1.toTex()}$ et $J = ${int2.toTex()}$. 
+ 
+Déterminer $I\\cap J$.`;
+};
+const getAnswer = (identifiers) => {
+    const [int1, int2] = [
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int1Identifiers),
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int2Identifiers),
+    ];
+    const inter = int1.intersection(int2);
+    return inter.toTex();
+};
+const getCorrection = (identifiers) => {
+    const [int1, int2] = [
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int1Identifiers),
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int2Identifiers),
+    ];
+    const inter = int1.intersection(int2);
+    const answer = inter.toTex();
+    return `$I$ contient les nombres ${int1.toText(true, false)}. 
+    
+$J$ contient les nombres ${int2.toText(false, false)}.
+    
+${(0, discreteSetNode_1.isDiscreteSetNode)(inter) && inter.elements.length === 0
+        ? `Il n'y a donc aucun nombre commun aux intervalles $I$ et $J$.`
+        : (0, discreteSetNode_1.isDiscreteSetNode)(inter) && inter.elements.length === 1
+            ? `Il n'y a donc qu'un nombre commun aux intervalles $I$ et $J$ : $${inter.elements[0].toTex()}$.`
+            : (0, intervalNode_1.isIntervalNode)(inter) &&
+                `Les nombres communs à $I$ et $J$ sont donc les nombres ${inter.toText(true, false)}.`}
+    
+Ainsi, $I\\cap J = ${answer}$`;
+};
 const getIntervalsIntersectionQuestion = () => {
-    const [int1, int2] = intervals_1.IntervalConstructor.differentRandoms(2);
+    const [int1, int2] = intervalNode_1.IntervalNodeConstructor.differentRandoms(2);
     const inter = int1.intersection(int2);
     const answer = inter.toTex();
+    const identifiers = {
+        int1Identifiers: int1.toIdentifiers(),
+        int2Identifiers: int2.toIdentifiers(),
+    };
     const question = {
-        answer,
-        instruction: `Soit $I = ${int1.toTex()}$ et $J = ${int2.toTex()}$. Déterminer $I\\cap J$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [
             "infty",
             "varnothing",
@@ -26,44 +93,46 @@ const getIntervalsIntersectionQuestion = () => {
             "rbrace",
         ],
         answerFormat: "tex",
-        identifiers: {
-            int1Closure: int1.closure,
-            int1Max: int1.max,
-            int1Min: int1.min,
-            int2Closure: int2.closure,
-            int2Max: int2.max,
-            int2Min: int2.min,
-        },
+        identifiers,
         hint: `Détermine l'ensemble des nombres qui appartiennent à la fois à $I$ et à $J$.`,
-        correction: `$I$ contient les nombres ${int1.toTree().toText(true, false)}. 
-    
-$J$ contient les nombres ${int2.toTree().toText(false, false)}.
-    
-${(0, discreteSetNode_1.isDiscreteSetNode)(inter) && inter.elements.length === 0
-            ? `Il n'y a donc aucun nombre commun aux intervalles $I$ et $J$.`
-            : (0, discreteSetNode_1.isDiscreteSetNode)(inter) && inter.elements.length === 1
-                ? `Il n'y a donc qu'un nombre commun aux intervalles $I$ et $J$ : $${inter.elements[0].toTex()}$.`
-                : (0, intervalNode_1.isIntervalNode)(inter) &&
-                    `Les nombres communs à $I$ et $J$ sont donc les nombres ${inter.toText(true, false)}.`}
-    
-Ainsi, $I\\cap J = ${answer}$`,
+        correction: getCorrection(identifiers),
     };
     return question;
 };
-const getPropositions = (n, { answer, int1Closure, int1Max, int1Min, int2Closure, int2Max, int2Min }) => {
+const getPropositions = (n, { answer, int1Identifiers, int2Identifiers }) => {
     const propositions = [];
+    const [int1, int2] = [
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(int1Identifiers),
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(int2Identifiers),
+    ];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const int1 = new intervals_1.Interval(int1Min.toTree(), int1Max.toTree(), int1Closure);
-    const int2 = new intervals_1.Interval(int2Min.toTree(), int2Max.toTree(), int2Closure);
-    (0, exercise_1.tryToAddWrongProp)(propositions, int1.union(int2).tex);
+    (0, exercise_1.tryToAddWrongProp)(propositions, int1.union(int2).toTex());
     while (propositions.length < n) {
-        const wrongAnswer = intervals_1.IntervalConstructor.random().tex;
+        const wrongAnswer = intervalNode_1.IntervalNodeConstructor.random().toTex();
         (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+const isAnswerValid = (ans, { answer, int1Identifiers, int2Identifiers }) => {
+    try {
+        if (answer === "\\varnothing")
+            return ans === answer;
+        if (answer.includes("\\{")) {
+            const setParsed = (0, discreteSetParser_1.discreteSetParser)(ans);
+            if (!setParsed)
+                return false;
+            return setParsed.simplify().toTex() === answer;
+        }
+        else {
+            const parsed = (0, intervalParser_1.intervalParser)(ans);
+            if (!parsed)
+                return false;
+            return parsed.simplify().toTex() === answer;
+        }
+    }
+    catch (err) {
+        return false;
+    }
 };
 exports.intervalsIntersection = {
     id: "intervalsIntersection",
@@ -79,4 +148,5 @@ exports.intervalsIntersection = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    rebuildIdentifiers,
 };

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

@@ -1,12 +1,8 @@
 import { Exercise } from "../../../../exercises/exercise";
-import { ClosureType } from "../../../../tree/nodes/sets/closure";
+import { IntervalNodeIdentifiers } from "../../../../tree/nodes/sets/intervalNode";
 type Identifiers = {
-    int1Min: number;
-    int1Max: number;
-    int1Closure: ClosureType;
-    int2Min: number;
-    int2Max: number;
-    int2Closure: ClosureType;
+    int1Identifiers: IntervalNodeIdentifiers;
+    int2Identifiers: IntervalNodeIdentifiers;
 };
 export declare const intervalsUnion: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/sets/intervals/intervalsUnion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalsUnion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAG5D,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AA6CF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}
+{"version":3,"file":"intervalsUnion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAGL,uBAAuB,EACxB,MAAM,oCAAoC,CAAC;AAI5C,KAAK,WAAW,GAAG;IAOjB,eAAe,EAAE,uBAAuB,CAAC;IACzC,eAAe,EAAE,uBAAuB,CAAC;CAC1C,CAAC;AAkGF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}