math-exercises 2.2.84 → 2.2.86

package/lib/exercises/math/functions/logarithm/logPowerEquation.js

@@ -15,6 +15,8 @@ const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
 const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
 const discreteSetNode_1 = require("../../../../tree/nodes/sets/discreteSetNode");
 const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
+const discreteSetParser_1 = require("../../../../tree/parsers/discreteSetParser");
+const equationSolutionParser_1 = require("../../../../tree/parsers/equationSolutionParser");
 /**a*b^x+c=d */
 const getKeys = (identifiers, opts) => {
     const keys = ["x", "equal", "S", "lbrace", "semicolon", "rbrace"];
@@ -59,23 +61,24 @@ const getPropositions = (n, { answer, isLog10, a, c, k, powered }) => {
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
-const isAnswerValid = (ans, { a, c, k, powered, isLog10 }) => {
+const isAnswerValid = (ans, { a, c, k, powered, isLog10, answer }) => {
     try {
-        //!TODO parse equation solution
+        const eqParsed = (0, equationSolutionParser_1.equationSolutionParser)(ans);
+        if (eqParsed) {
+            const set = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([eqParsed]));
+            return set.simplify().toTex() === answer;
+        }
+        else {
+            const setParsed = (0, discreteSetParser_1.discreteSetParser)(ans);
+            if (!setParsed) {
+                return false;
+            }
+            return "S=" + setParsed.simplify().toTex() === answer;
+        }
     }
     catch (err) {
         return false;
     }
-    const LNode = isLog10 ? log10Node_1.Log10Node : logNode_1.LogNode;
-    const poweredNode = new numberNode_1.NumberNode(powered);
-    const answerSimp = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
-        new fractionNode_1.FractionNode(new LNode(new numberNode_1.NumberNode(k)), new LNode(poweredNode)).simplify(),
-    ]));
-    const answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
-        new fractionNode_1.FractionNode(new LNode(new numberNode_1.NumberNode(k)), new LNode(poweredNode)),
-    ]));
-    const texs = [...answerSimp.toAllValidTexs(), ...answer.toAllValidTexs()];
-    return texs.includes(ans);
 };
 exports.logPowerEquation = {
     id: "logPowerEquation",

package/lib/exercises/math/functions/sign/affineProductSign.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { GeneralAffineIdentifiers } from "../../../../math/polynomials/generalAffine";
+type Identifiers = {
+    affine1Ids: GeneralAffineIdentifiers;
+    affine2Ids: GeneralAffineIdentifiers;
+    isAskingPositive: boolean;
+};
+type Options = {
+    instructionType: string;
+};
+export declare const affineProductSign: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=affineProductSign.d.ts.map

package/lib/exercises/math/functions/sign/affineProductSign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affineProductSign.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/affineProductSign.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAGL,wBAAwB,EACzB,MAAM,sCAAsC,CAAC;AAc9C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,wBAAwB,CAAC;IACrC,UAAU,EAAE,wBAAwB,CAAC;IACrC,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AA8IF,KAAK,OAAO,GAAG;IACb,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAaF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB5D,CAAC"}

package/lib/exercises/math/functions/sign/affineProductSign.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.affineProductSign = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const generalAffine_1 = require("../../../../math/polynomials/generalAffine");
+const randint_1 = require("../../../../math/utils/random/randint");
+const infiniteNode_1 = require("../../../../tree/nodes/numbers/infiniteNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const closure_1 = require("../../../../tree/nodes/sets/closure");
+const intervalNode_1 = require("../../../../tree/nodes/sets/intervalNode");
+const unionIntervalNode_1 = require("../../../../tree/nodes/sets/unionIntervalNode");
+const unionIntervalParser_1 = require("../../../../tree/parsers/unionIntervalParser");
+const coinFlip_1 = require("../../../../utils/alea/coinFlip");
+const doWhile_1 = require("../../../../utils/doWhile");
+const getPropositions = (n, { answer, ...identifiers }, opts) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const { affine1Ids, affine2Ids, isAskingPositive } = identifiers;
+    const affine1 = generalAffine_1.GeneralAffineConstructor.fromIdentifiers(affine1Ids);
+    const affine2 = generalAffine_1.GeneralAffineConstructor.fromIdentifiers(affine2Ids);
+    let root1 = affine1.getRoot();
+    let root2 = affine2.getRoot();
+    if (root1.evaluate() > root2.evaluate()) {
+        [root1, root2] = [root2, root1];
+    }
+    const insideInt = new intervalNode_1.IntervalNode(root1, root2, closure_1.ClosureType.FF);
+    const outsideInt = new unionIntervalNode_1.UnionIntervalNode([
+        new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, root1, closure_1.ClosureType.OF),
+        new intervalNode_1.IntervalNode(root2, infiniteNode_1.PlusInfinityNode, closure_1.ClosureType.FO),
+    ]);
+    (0, exercise_1.tryToAddWrongProp)(propositions, insideInt.toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, outsideInt.toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, root1, closure_1.ClosureType.OF).toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, new intervalNode_1.IntervalNode(root2, infiniteNode_1.PlusInfinityNode, closure_1.ClosureType.FO).toTex());
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const { affine1Ids, affine2Ids, isAskingPositive } = identifiers;
+    const affine1 = generalAffine_1.GeneralAffineConstructor.fromIdentifiers(affine1Ids);
+    const affine2 = generalAffine_1.GeneralAffineConstructor.fromIdentifiers(affine2Ids);
+    let root1 = affine1.getRoot();
+    let root2 = affine2.getRoot();
+    if (root1.evaluate() > root2.evaluate()) {
+        [root1, root2] = [root2, root1];
+    }
+    const trinomA = (0, multiplyNode_1.multiply)(affine1.a, affine2.a).evaluate();
+    const insideInt = new intervalNode_1.IntervalNode(root1, root2, closure_1.ClosureType.FF);
+    const outsideInt = new unionIntervalNode_1.UnionIntervalNode([
+        new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, root1, closure_1.ClosureType.OF),
+        new intervalNode_1.IntervalNode(root2, infiniteNode_1.PlusInfinityNode, closure_1.ClosureType.FO),
+    ]);
+    if (trinomA > 0 === isAskingPositive)
+        return outsideInt;
+    else
+        return insideInt;
+};
+const getAnswer = (identifiers, opts) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers, opts) => {
+    const { affine1Ids, affine2Ids, isAskingPositive } = identifiers;
+    const affine1 = generalAffine_1.GeneralAffineConstructor.fromIdentifiers(affine1Ids);
+    const affine2 = generalAffine_1.GeneralAffineConstructor.fromIdentifiers(affine2Ids);
+    const isInequation = opts?.instructionType === "Résoudre l'inéquation";
+    return isInequation
+        ? `Résoudre l'inéquation : 
+  
+$$
+${(0, multiplyNode_1.multiply)(affine1.toTree(), affine2.toTree()).toTex()} ${isAskingPositive ? "\\ge" : "\\le"}0 
+$$`
+        : `Soit $f$ la fonction définie sur $\\mathbb{R}$ par : 
+  
+$$
+f(x) = ${(0, multiplyNode_1.multiply)(affine1.toTree(), affine2.toTree()).toTex()}
+$$
+
+Sur quel(s) intervalle(s) $f$ est-elle ${isAskingPositive ? "positive" : "négative"} ?`;
+};
+// const getHint: GetHint<Identifiers, Options> = (identifiers, opts) => {};
+// const getCorrection: GetCorrection<Identifiers, Options> = (identifiers) => {};
+const getKeys = (identifiers, opts) => {
+    return ["lbracket", "semicolon", "rbracket", "cup", "infty"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
+    try {
+        const parsed = (0, unionIntervalParser_1.unionIntervalParser)(ans, { allowNoBrackets: true });
+        if (!parsed)
+            return false;
+        const ansNode = getAnswerNode(identifiers);
+        return (parsed.simplify().toClosedForm().toTex() ===
+            ansNode.toClosedForm().toTex());
+    }
+    catch (err) {
+        return false;
+    }
+};
+const getAffineProductSignQuestion = (opts) => {
+    const a = (0, randint_1.randint)(-9, 10, [0]);
+    const b = (0, randint_1.randint)(-9, 10, [0]);
+    const c = (0, randint_1.randint)(-10, 10, [0]);
+    const d = (0, doWhile_1.doWhile)(() => (0, randint_1.randint)(-10, 10, [0]), (x) => c / a === x / b);
+    const affine1 = new generalAffine_1.GeneralAffine(a, b);
+    const affine2 = new generalAffine_1.GeneralAffine(c, d);
+    const identifiers = {
+        affine1Ids: affine1.toIdentifiers(),
+        affine2Ids: affine2.toIdentifiers(),
+        isAskingPositive: (0, coinFlip_1.coinFlip)(),
+    };
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers, opts),
+        // correction: getCorrection(identifiers, opts),
+    };
+    return question;
+};
+const options = [
+    {
+        id: "instructionType",
+        label: "Type de consigne",
+        target: exercise_1.GeneratorOptionTarget.instruction,
+        type: exercise_1.GeneratorOptionType.select,
+        defaultValue: "Déterminer le signe de la fonction",
+        values: ["Résoudre l'inéquation", "Déterminer le signe de la fonction"],
+    },
+];
+exports.affineProductSign = {
+    id: "affineProductSign",
+    connector: "\\iff",
+    label: "Déterminer le signe de $(ax+b)(cx+d)$",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getAffineProductSignQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    // getHint,
+    // getCorrection,
+    getAnswer,
+    options,
+};

package/lib/exercises/math/functions/sign/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./affineProductSign";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/sign/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/lib/exercises/math/functions/sign/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./affineProductSign"), exports);

package/lib/exercises/math/geometry/parametric/extractPointFromParametricLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractPointFromParametricLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/parametric/extractPointFromParametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAyHF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAiBhE,CAAC"}
+{"version":3,"file":"extractPointFromParametricLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/parametric/extractPointFromParametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAwHF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAiBhE,CAAC"}

package/lib/exercises/math/geometry/parametric/extractPointFromParametricLine.js

@@ -46,8 +46,7 @@ const getCorrection = (identifiers) => {
     const point = line.getPointCoords(new numberNode_1.NumberNode(0));
     return `Pour obtenir les coordonnées d'un point appartenant à la droite, il suffit de remplacer $t$ par n'importe quelle valeur dans les trois équations. Par simplicité, prenons $t = 0$. On obtient alors : 
   
-$$
-\\left\\{\\begin{matrix}
+$$\\left\\{\\begin{matrix}
 x=${detailedEquations[0].toTex()} \\\\
 y=${detailedEquations[1].toTex()} \\\\
 z=${detailedEquations[2].toTex()} 

package/lib/exercises/math/percent/averageEvolutionRate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"averageEvolutionRate.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/averageEvolutionRate.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA0EF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"averageEvolutionRate.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/averageEvolutionRate.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,QAAQ,EAYT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAgGF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAkBtD,CAAC"}

package/lib/exercises/math/percent/averageEvolutionRate.js

@@ -6,38 +6,57 @@ const round_1 = require("../../../math/utils/round");
 const shuffle_1 = require("../../../utils/alea/shuffle");
 const exercise_1 = require("../../exercise");
 const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
-const getAverageEvolutionRate = () => {
-    const rate = (0, randint_1.randint)(1, 100);
-    const nbMois = (0, randint_1.randint)(2, 13);
-    const instruction = `Un prix augmente de $${rate}\\%$ en $${nbMois}$ mois. Quel est le taux d'évolution mensuel moyen (arrondir au centième de pourcentage) ?`;
+const getInstruction = (identifiers) => {
+    const { rate, nbMois } = identifiers;
+    return `Un prix augmente de $${rate}\\%$ en $${nbMois}$ mois. Quel est le taux d'évolution mensuel moyen ? Arrondir au centième de pourcentage.`;
+};
+const getAnswer = (identifiers) => {
+    const { rate, nbMois } = identifiers;
     const answer = (0, round_1.round)((Math.pow(1 + rate / 100, 1 / nbMois) - 1) * 100, 2);
     const answerTex = (answer + "").replace(".", ",") + `\\%`;
-    const question = {
-        instruction,
-        answer: answerTex,
-        keys: ["percent"],
-        answerFormat: "tex",
-        identifiers: { nbMois, rate },
-        hint: `Commence par déterminer le coefficient multiplicateur assoicié à une hausse de $${rate}\\%$. Puis, élève ce coefficient à la puissance $\\frac{1}{${nbMois}}$. Enfin, transforme le coefficient multiplicateur obtenu en taux d'évolution.`,
-        correction: `Le coefficient multiplicateur associé à une hausse de $${rate}\\%$ est : 
+    return answerTex;
+};
+const getHint = (identifiers) => {
+    const { rate, nbMois } = identifiers;
+    return `Commence par déterminer le coefficient multiplicateur assoicié à une hausse de $${rate}\\%$. Puis, élève ce coefficient à la puissance $\\frac{1}{${nbMois}}$. Enfin, transforme le coefficient multiplicateur obtenu en taux d'évolution.`;
+};
+const getCorrection = (identifiers) => {
+    const { rate, nbMois } = identifiers;
+    const answer = getAnswer(identifiers);
+    const cm = (0, round_1.round)(1 + rate / 100, 2);
+    const answerNoPercent = answer.split("\\%")[0];
+    return `Le coefficient multiplicateur associé à une hausse de $${rate}\\%$ est : 
 
 $$
-1+\\frac{${rate}}{100} = ${(1 + rate / 100).frenchify()}
+1+\\frac{${rate}}{100} = ${cm.frenchify()}
 $$
 
 Le coefficient multiplicateur moyen pour chaque mois sur une période de $${nbMois}$ mois est donc de : 
 
-$$\\left(${(1 +
-            rate / 100).frenchify()}\\right)^{\\frac{1}{${nbMois}}} = ${(0, round_1.round)(Math.pow(1 + rate / 100, 1 / nbMois), 4).frenchify()}
+$$
+${cm.frenchify()}^{\\frac{1}{${nbMois}}} = ${(0, round_1.round)(Math.pow(cm, 1 / nbMois), 4).frenchify()}
 $$
 
 On transforme alors ce coefficient multiplicateur en taux d'évolution :
 
 $$
-t = (${(0, round_1.round)(Math.pow(1 + rate / 100, 1 / nbMois), 4).frenchify()}-1)\\times 100 = ${answer.frenchify()}
+t = (${(0, round_1.round)(Math.pow(cm, 1 / nbMois), 4).frenchify()}-1)\\times 100 = ${answerNoPercent}
 $$
 
-Le taux d'évoution mensuel moyen est donc de $${answerTex}$.`,
+Le taux d'évoution mensuel moyen est donc de $${answer}$.`;
+};
+const getAverageEvolutionRate = () => {
+    const rate = (0, randint_1.randint)(1, 100);
+    const nbMois = (0, randint_1.randint)(2, 13);
+    const identifiers = { nbMois, rate };
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["percent"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -73,4 +92,8 @@ exports.averageEvolutionRate = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getCorrection,
+    getAnswer,
+    getInstruction,
+    getHint,
 };

package/lib/exercises/math/percent/cmToEvolution.js

@@ -40,7 +40,7 @@ Le taux d'évolution est donc de $${answer}$.
 const getPropositions = (n, { answer, evolution }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    (0, exercise_1.tryToAddWrongProp)(propositions, "+" + ((0, round_1.round)(1 + evolution / 100, 2) * 100 + "\\%").replaceAll(".", ","));
+    (0, exercise_1.tryToAddWrongProp)(propositions, "+" + ((0, round_1.round)(100 + evolution, 2) + "\\%").replaceAll(".", ","));
     while (propositions.length < n) {
         const wrongAnswer = ((0, coinFlip_1.coinFlip)() ? "+" : "-") + (0, randint_1.randint)(1, 100) + "\\%";
         (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);

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,EAUT,MAAM,0BAA0B,CAAC;AAQlC,OAAO,EAGL,uBAAuB,EACxB,MAAM,oCAAoC,CAAC;AAI5C,KAAK,WAAW,GAAG;IAIjB,mBAAmB,EAAE,uBAAuB,CAAC;CAC9C,CAAC;AA2FF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}
+{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAQlC,OAAO,EAGL,uBAAuB,EACxB,MAAM,oCAAoC,CAAC;AAI5C,KAAK,WAAW,GAAG;IAIjB,mBAAmB,EAAE,uBAAuB,CAAC;CAC9C,CAAC;AAwGF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}

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

@@ -26,17 +26,24 @@ const rebuildIdentifiers = (oldIds) => {
     const interval = new intervalNode_1.IntervalNode(a, b, closure);
     return { intervalIdentifiers: interval.toIdentifiers() };
 };
-const getInequalityToIntervalQuestion = () => {
-    const interval = intervalNode_1.IntervalNodeConstructor.random();
+const getInstruction = (identifiers) => {
+    const interval = intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.intervalIdentifiers);
     const inequality = interval.toInequality();
+    return `Soit $${inequality.toTex()}$. Traduire cette inégalité en appartenance à un intervalle.`;
+};
+const getAnswer = (identifiers) => {
+    const interval = intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.intervalIdentifiers);
     const answer = `x\\in\\ ${interval.toTex()}`;
-    const instruction = `Soit $${inequality.toTex()}$. Traduire cette inégalité en appartenance à un intervalle.`;
+    return answer;
+};
+const getInequalityToIntervalQuestion = () => {
+    const interval = intervalNode_1.IntervalNodeConstructor.random();
     const identifiers = {
         intervalIdentifiers: interval.toIdentifiers(),
     };
     const question = {
-        answer,
-        instruction: instruction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [
             "x",
             "belongs",
@@ -89,4 +96,6 @@ exports.inequalityToInterval = {
     isAnswerValid,
     subject: "Mathématiques",
     rebuildIdentifiers,
+    getAnswer,
+    getInstruction,
 };

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,EAYT,MAAM,0BAA0B,CAAC;AAWlC,OAAO,EAGL,uBAAuB,EACxB,MAAM,oCAAoC,CAAC;AAK5C,KAAK,WAAW,GAAG;IAIjB,mBAAmB,EAAE,uBAAuB,CAAC;CAC9C,CAAC;AAsFF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,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;AAsFF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}

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

@@ -79,4 +79,6 @@ exports.intervalToInequality = {
     isAnswerValid,
     subject: "Mathématiques",
     rebuildIdentifiers,
+    getAnswer,
+    getInstruction,
 };

package/lib/exercises/math/trigonometry/degreeToRadians.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"degreeToRadians.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/degreeToRadians.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,GAAG,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAkJF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAiBjD,CAAC"}
+{"version":3,"file":"degreeToRadians.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/degreeToRadians.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,0BAA0B,CAAC;AAgBlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,GAAG,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAwJF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAiBjD,CAAC"}

package/lib/exercises/math/trigonometry/degreeToRadians.js

@@ -10,6 +10,8 @@ const nodeConstructor_1 = require("../../../tree/nodes/nodeConstructor");
 const piNode_1 = require("../../../tree/nodes/numbers/piNode");
 const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
 const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const degreeParser_1 = require("../../../tree/parsers/degreeParser");
+const latexParser_1 = require("../../../tree/parsers/latexParser");
 const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const random_1 = require("../../../utils/alea/random");
 const getPropositions = (n, { answer, isDegreeToRadian }) => {
@@ -76,13 +78,22 @@ const getKeys = (identifiers) => {
     return ["pi", "degree"];
 };
 const isAnswerValid = (ans, { answer, degree, isDegreeToRadian, radianNodeIds }) => {
-    if (isDegreeToRadian) {
-        return nodeConstructor_1.NodeConstructor.fromIdentifiers(radianNodeIds)
-            .toAllValidTexs()
-            .includes(ans);
+    try {
+        if (isDegreeToRadian) {
+            const parsed = (0, latexParser_1.parseAlgebraic)(ans);
+            if (!parsed)
+                return false;
+            return parsed.simplify({ decimalToFractions: true }).toTex() === answer;
+        }
+        else {
+            const parsed = (0, degreeParser_1.degreeParser)(ans, true);
+            if (!parsed)
+                return false;
+            return parsed === answer;
+        }
     }
-    else {
-        return new degree_1.DegreeNode(degree).toAllValidTexs().includes(ans);
+    catch (err) {
+        return false;
     }
 };
 const getIdentifiers = (prevIds) => {

package/lib/index.d.ts

@@ -919,6 +919,12 @@ declare const mathExercises: (Exercise<{
     q: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
     a: number;
 }, {}> | Exercise<{
+    affine1Ids: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers;
+    affine2Ids: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers;
+    isAskingPositive: boolean;
+}, {
+    instructionType: string;
+}> | Exercise<{
     coin: boolean;
     radius: number;
     diametre: 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/parametricLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parametricLine.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/parametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAA0B,MAAM,eAAe,CAAC;AAEpE,qBAAa,cAAc;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,aAAa,EAAE,CAAC;gBACf,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW;IAavD,oBAAoB,CAAC,CAAC,EAAE,aAAa;IAIrC,cAAc,CAAC,CAAC,EAAE,aAAa;IAG/B,QAAQ,CAAC,CAAC,EAAE,aAAa;IAKzB,QAAQ,CAAC,CAAC,EAAE,UAAU;IAYtB,KAAK;CAUN"}
+{"version":3,"file":"parametricLine.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/parametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAA0B,MAAM,eAAe,CAAC;AAEpE,qBAAa,cAAc;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,aAAa,EAAE,CAAC;gBACf,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW;IAavD,oBAAoB,CAAC,CAAC,EAAE,aAAa;IAIrC,cAAc,CAAC,CAAC,EAAE,aAAa;IAG/B,QAAQ,CAAC,CAAC,EAAE,aAAa;IAKzB,QAAQ,CAAC,CAAC,EAAE,UAAU;IAYtB,KAAK;CAQN"}

package/lib/math/geometry/parametricLine.js

@@ -33,14 +33,12 @@ class ParametricLine {
         return vector1.isColinear(vector2);
     }
     toTex() {
-        return `
-\\left\\{\\begin{matrix}
+        return `\\left\\{\\begin{matrix}
 x=${this.equations[0].toTex()} \\\\
 y=${this.equations[1].toTex()} \\\\
 z=${this.equations[2].toTex()} 
 \\end{matrix}
-\\right.
-`;
+\\right.`;
     }
 }
 exports.ParametricLine = ParametricLine;

package/lib/math/polynomials/generalAffine.d.ts

@@ -1,5 +1,6 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
 import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor";
+import { IntervalNode } from "../../tree/nodes/sets/intervalNode";
 export declare abstract class GeneralAffineConstructor {
     static fromIdentifiers(identifiers: GeneralAffineIdentifiers): GeneralAffine;
     static randomInts({ allowBNull }: {
@@ -19,6 +20,8 @@ export declare class GeneralAffine {
     constructor(a: number | AlgebraicNode, b: number | AlgebraicNode, variable?: string);
     toIdentifiers(): GeneralAffineIdentifiers;
     getRoot(): AlgebraicNode;
+    getPositiveInterval(): IntervalNode;
+    getNegativeInterval(): IntervalNode;
     toTree(): import("../../tree/nodes/operators/addNode").AddNode | import("../../tree/nodes/operators/multiplyNode").MultiplyNode;
     xIntersect(aff: GeneralAffine): AlgebraicNode | undefined;
     opposite(): GeneralAffine;

package/lib/math/polynomials/generalAffine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generalAffine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalAffine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAEL,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAS1C,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,wBAAwB;IAM5D,MAAM,CAAC,UAAU,CAAC,EAAE,UAAiB,EAAE;;KAAA,EAAE,QAAQ,SAAM;CAOxD;AACD,MAAM,MAAM,wBAAwB,GAAG;IACrC,EAAE,EAAE,QAAQ,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,qBAAa,aAAa;IACxB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;gBAGf,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,QAAQ,GAAE,MAAY;IAUxB,aAAa,IAAI,wBAAwB;IAQzC,OAAO,IAAI,aAAa;IAIxB,MAAM;IAMN,UAAU,CAAC,GAAG,EAAE,aAAa;IAI7B,QAAQ;CAMT"}
+{"version":3,"file":"generalAffine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalAffine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAEL,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAU1C,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAKlE,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,wBAAwB;IAM5D,MAAM,CAAC,UAAU,CAAC,EAAE,UAAiB,EAAE;;KAAA,EAAE,QAAQ,SAAM;CAOxD;AACD,MAAM,MAAM,wBAAwB,GAAG;IACrC,EAAE,EAAE,QAAQ,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,qBAAa,aAAa;IACxB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;gBAGf,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,QAAQ,GAAE,MAAY;IAUxB,aAAa,IAAI,wBAAwB;IAQzC,OAAO,IAAI,aAAa;IAGxB,mBAAmB,IAAI,YAAY;IAQnC,mBAAmB,IAAI,YAAY;IASnC,MAAM;IAMN,UAAU,CAAC,GAAG,EAAE,aAAa;IAI7B,QAAQ;CAMT"}

package/lib/math/polynomials/generalAffine.js

@@ -3,10 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GeneralAffine = exports.GeneralAffineConstructor = void 0;
 const oppositeNode_1 = require("../../tree/nodes/functions/oppositeNode");
 const nodeConstructor_1 = require("../../tree/nodes/nodeConstructor");
+const infiniteNode_1 = require("../../tree/nodes/numbers/infiniteNode");
 const addNode_1 = require("../../tree/nodes/operators/addNode");
 const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const substractNode_1 = require("../../tree/nodes/operators/substractNode");
+const closure_1 = require("../../tree/nodes/sets/closure");
+const intervalNode_1 = require("../../tree/nodes/sets/intervalNode");
 const randint_1 = require("../utils/random/randint");
 class GeneralAffineConstructor {
     static fromIdentifiers(identifiers) {
@@ -42,6 +45,24 @@ class GeneralAffine {
     getRoot() {
         return (0, fractionNode_1.frac)((0, oppositeNode_1.opposite)(this.b), this.a).simplify();
     }
+    getPositiveInterval() {
+        const root = this.getRoot();
+        if (this.a.evaluate() > 0) {
+            return new intervalNode_1.IntervalNode(root, infiniteNode_1.PlusInfinityNode, closure_1.ClosureType.OO);
+        }
+        else {
+            return new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, root, closure_1.ClosureType.OO);
+        }
+    }
+    getNegativeInterval() {
+        const root = this.getRoot();
+        if (this.a.evaluate() < 0) {
+            return new intervalNode_1.IntervalNode(root, infiniteNode_1.PlusInfinityNode, closure_1.ClosureType.OO);
+        }
+        else {
+            return new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, root, closure_1.ClosureType.OO);
+        }
+    }
     toTree() {
         const monom = (0, multiplyNode_1.multiply)(this.a, this.variable);
         if (this.b.evaluate() === 0)

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAsDA,eAAO,MAAM,UAAU,YAGtB,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAwDA,eAAO,MAAM,UAAU,YAAW,CAAC"}

package/lib/playground.js

@@ -1,13 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
-const sqrtNode_1 = require("./tree/nodes/functions/sqrtNode");
 const nodeConstructor_1 = require("./tree/nodes/nodeConstructor");
-const multiplyNode_1 = require("./tree/nodes/operators/multiplyNode");
-const playground = () => {
-    const a = (0, multiplyNode_1.multiply)(3, (0, sqrtNode_1.sqrt)(2));
-    console.log(a.simplify().toTex());
-};
+const playground = () => { };
 exports.playground = playground;
 const logIdentifiers = () => {
     const ids = '{"xA":-3,"yA":-2,"yPrimeA":{"id":31,"child":{"id":3,"leftChild":{"id":7,"value":3},"rightChild":{"id":7,"value":2}}},"trinomCoeffs":[0.3888888888888889,0.833333333333333,-3]}';

package/lib/tree/nodes/algebraicNode.d.ts

@@ -7,6 +7,7 @@ export type SimplifyOptions = {
     isDegree?: boolean;
     towardsDistribute?: boolean;
     decimalToFractions?: boolean;
+    forceIsolateMonomCoeffs?: boolean;
 };
 export interface AlgebraicNode extends Node {
     evaluate: (vars?: Record<string, number>) => number;

package/lib/tree/nodes/algebraicNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE3C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IACpD,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,aAAa,CAAC;IACpD,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;CACjD;AAED,eAAO,MAAM,eAAe,SAAU,IAAI,0BACA,CAAC"}
+{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE3C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IACpD,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,aAAa,CAAC;IACpD,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;CACjD;AAED,eAAO,MAAM,eAAe,SAAU,IAAI,0BACA,CAAC"}

package/lib/tree/nodes/equations/equationSolutionNode.d.ts

@@ -24,7 +24,7 @@ export declare class EquationSolutionNode implements Node {
     toEquivalentNodes(opts?: NodeOptions): EquationSolutionNode[];
     toMathString(): string;
     toTex(): string;
-    simplify(): this;
+    simplify(): EquationSolutionNode;
 }
 export {};
 //# sourceMappingURL=equationSolutionNode.d.ts.map