math-exercises 2.2.83 → 2.2.85

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,CActD,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;
 };

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;AAqFF,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,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"}

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

@@ -10,10 +10,16 @@ const shuffle_1 = require("../../../../utils/alea/shuffle");
 const rebuildIdentifiers = (oldIds) => {
     if (!!oldIds.intervalIdentifiers)
         return oldIds;
-    const a = oldIds.intervalMin === "-infty" || oldIds.intervalMin === -Infinity
+    const a = oldIds.intervalMin === "-infty" ||
+        oldIds.intervalMin === -Infinity ||
+        oldIds.intervalMin === null ||
+        oldIds.intervalMin === undefined
         ? infiniteNode_1.MinusInfinityNode
         : oldIds.intervalMin.toTree();
-    const b = oldIds.intervalMax === "infty" || oldIds.intervalMax === Infinity
+    const b = oldIds.intervalMax === "infty" ||
+        oldIds.intervalMax === Infinity ||
+        oldIds.intervalMax === null ||
+        oldIds.intervalMax === undefined
         ? infiniteNode_1.PlusInfinityNode
         : oldIds.intervalMax.toTree();
     const closure = oldIds.intervalClosure;

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;AAgFF,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,CAetD,CAAC"}

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

@@ -9,10 +9,16 @@ const shuffle_1 = require("../../../../utils/alea/shuffle");
 const rebuildIdentifiers = (oldIds) => {
     if (!!oldIds.intervalIdentifiers)
         return oldIds;
-    const a = oldIds.intervalMin === "-infty" || oldIds.intervalMin === -Infinity
+    const a = oldIds.intervalMin === "-infty" ||
+        oldIds.intervalMin === -Infinity ||
+        oldIds.intervalMin === null ||
+        oldIds.intervalMin === undefined
         ? infiniteNode_1.MinusInfinityNode
         : oldIds.intervalMin.toTree();
-    const b = oldIds.intervalMax === "infty" || oldIds.intervalMax === Infinity
+    const b = oldIds.intervalMax === "infty" ||
+        oldIds.intervalMax === Infinity ||
+        oldIds.intervalMax === null ||
+        oldIds.intervalMax === undefined
         ? infiniteNode_1.PlusInfinityNode
         : oldIds.intervalMax.toTree();
     const closure = oldIds.intervalClosure;

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,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"}
+{"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;AAgKF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}

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

@@ -12,18 +12,30 @@ const shuffle_1 = require("../../../../utils/alea/shuffle");
 const rebuildIdentifiers = (oldIds) => {
     if (!!oldIds.int1Identifiers)
         return oldIds;
-    const a1 = oldIds.int1Min === "-infty" || oldIds.int2Min === -Infinity
+    const a1 = oldIds.int1Min === "-infty" ||
+        oldIds.int2Min === -Infinity ||
+        oldIds.int1Min === null ||
+        oldIds.int1Min === undefined
         ? infiniteNode_1.MinusInfinityNode
         : oldIds.int1Min.toTree();
-    const b1 = oldIds.int1Max === "infty" || oldIds.int1Max === Infinity
+    const b1 = oldIds.int1Max === "infty" ||
+        oldIds.int1Max === Infinity ||
+        oldIds.int1Max === null ||
+        oldIds.int1Max === undefined
         ? 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
+    const a2 = oldIds.int2Min === "-infty" ||
+        oldIds.int2Min === -Infinity ||
+        oldIds.int2Min === null ||
+        oldIds.int2Min === undefined
         ? infiniteNode_1.MinusInfinityNode
         : oldIds.int2Min.toTree();
-    const b2 = oldIds.int2Max === "infty" || oldIds.int2Max === Infinity
+    const b2 = oldIds.int2Max === "infty" ||
+        oldIds.int2Max === Infinity ||
+        oldIds.int2Max === null ||
+        oldIds.int2Max === undefined
         ? infiniteNode_1.PlusInfinityNode
         : oldIds.int2Max.toTree();
     const closure2 = oldIds.int2Closure;

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,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"}
+{"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;AA8GF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}

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

@@ -10,18 +10,30 @@ const shuffle_1 = require("../../../../utils/alea/shuffle");
 const rebuildIdentifiers = (oldIds) => {
     if (!!oldIds.int1Identifiers)
         return oldIds;
-    const a1 = oldIds.int1Min === "-infty" || oldIds.int2Min === -Infinity
+    const a1 = oldIds.int1Min === "-infty" ||
+        oldIds.int2Min === -Infinity ||
+        oldIds.int1Min === null ||
+        oldIds.int1Min === undefined
         ? infiniteNode_1.MinusInfinityNode
         : oldIds.int1Min.toTree();
-    const b1 = oldIds.int1Max === "infty" || oldIds.int1Max === Infinity
+    const b1 = oldIds.int1Max === "infty" ||
+        oldIds.int1Max === Infinity ||
+        oldIds.int1Max === null ||
+        oldIds.int1Max === undefined
         ? 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
+    const a2 = oldIds.int2Min === "-infty" ||
+        oldIds.int2Min === -Infinity ||
+        oldIds.int2Min === null ||
+        oldIds.int2Min === undefined
         ? infiniteNode_1.MinusInfinityNode
         : oldIds.int2Min.toTree();
-    const b2 = oldIds.int2Max === "infty" || oldIds.int2Max === Infinity
+    const b2 = oldIds.int2Max === "infty" ||
+        oldIds.int2Max === Infinity ||
+        oldIds.int2Max === null ||
+        oldIds.int2Max === undefined
         ? infiniteNode_1.PlusInfinityNode
         : oldIds.int2Max.toTree();
     const closure2 = oldIds.int2Closure;

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"}