math-exercises 3.0.140 → 3.0.142

package/lib/exercises/math/calculLitteral/equation/proportionEquation.js

@@ -0,0 +1,152 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { isVariableNode, VariableNode, } from "../../../../tree/nodes/variables/variableNode.js";
+import { arrayRotation } from "../../../../utils/arrays/rotation.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, aIds, bIds, cIds, dIds }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const ids = [aIds, bIds, cIds, dIds];
+    for (let i = 0; i < 3; i++) {
+        const rotated = arrayRotation(ids, i + 1);
+        tryToAddWrongProp(propositions, getAnswerNode({
+            aIds: rotated[0],
+            bIds: rotated[1],
+            cIds: rotated[2],
+            dIds: rotated[3],
+        }).toTex());
+    }
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductible().toTree().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const { aIds, bIds, cIds, dIds } = identifiers;
+    const values = [aIds, bIds, cIds, dIds].map((e) => reifyAlgebraic(e));
+    //a/b=c/d
+    //a=cb/d, b=ad/c, c=ad/b, d=cb/a
+    const xIndex = values.findIndex((x) => isVariableNode(x));
+    return frac(multiply(values[(xIndex + 2) % 4], values[xIndex % 2 === 0 ? xIndex + 1 : xIndex - 1]), values[3 - xIndex]).simplify();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { aIds, bIds, cIds, dIds } = identifiers;
+    const [a, b, c, d] = [aIds, bIds, cIds, dIds].map((e) => reifyAlgebraic(e).toTex());
+    return `Déterminer la valeur de $x$ solution de l'équation suivante :
+  
+$$
+\\frac{${a}}{${b}}=\\frac{${c}}{${d}}
+$$`;
+};
+const getHint = () => {
+    return `Si deux fractions sont égales : 
+  
+$$
+\\frac{a}{b}=\\frac{c}{d}
+$$
+
+alors on a : 
+
+$$
+a\\times d = b\\times c
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, bIds, cIds, dIds } = identifiers;
+    const values = [aIds, bIds, cIds, dIds].map((e) => reifyAlgebraic(e));
+    const xIndex = values.findIndex((x) => isVariableNode(x));
+    const answerRaw = frac(multiply(values[(xIndex + 2) % 4], values[xIndex % 2 === 0 ? xIndex + 1 : xIndex - 1]), values[3 - xIndex]);
+    return `Puisque : 
+  
+$$
+\\frac{${values[0].toTex()}}{${values[1].toTex()}}=\\frac{${values[2].toTex()}}{${values[3].toTex()}}
+$$
+
+alors :
+
+$$
+${multiply(values[0], values[3]).toTex()}= ${multiply(values[1], values[2]).toTex()}
+$$
+
+On a donc : 
+
+${alignTex([
+        ["x", "=", answerRaw.toTex()],
+        ["", "=", answerRaw.simplify().toTex()],
+    ])}
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer, {
+            allowNonIrreductible: true,
+            allowDecimal: true,
+        });
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getProportionEquationQuestion = () => {
+    const x = new VariableNode("x");
+    const values = [];
+    const numbers = [];
+    const xIndex = randint(0, 4);
+    for (let i = 0; i < 4; i++) {
+        if (i === xIndex)
+            values[i] = x.toIdentifiers();
+        else {
+            numbers[i] = randint(1, 12, i % 2 !== 0 ? [1, numbers[i - 1]] : []);
+            values[i] = numbers[i].toTree().toIdentifiers();
+        }
+    }
+    const identifiers = {
+        aIds: values[0],
+        bIds: values[1],
+        cIds: values[2],
+        dIds: values[3],
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const proportionEquation = {
+    id: "proportionEquation",
+    connector: "=",
+    label: "Résoudre une équation de proportionnalité du type $\\frac ab = \\frac xc$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getProportionEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calculLitteral/equation/solveByFactorizingWithIdRmq3.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aIds: NodeIdentifiers;
+    bIds: NodeIdentifiers;
+};
+type Options = {
+    useSetAsAnswer: boolean;
+};
+export declare const solveByFactorizingWithIdRmq3: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=solveByFactorizingWithIdRmq3.d.ts.map

package/lib/exercises/math/calculLitteral/equation/solveByFactorizingWithIdRmq3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solveByFactorizingWithIdRmq3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/solveByFactorizingWithIdRmq3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA0LF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAUF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBvE,CAAC"}

package/lib/exercises/math/calculLitteral/equation/solveByFactorizingWithIdRmq3.js

@@ -0,0 +1,197 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        let a = randint(-10, 11, [0]);
+        let b = randint(-10, 11, [0, a]);
+        if (a > b)
+            [a, b] = [b, a];
+        tryToAddWrongProp(propositions, `x=${a}\\text{ ou }x=${b}`);
+    });
+    return shuffleProps(propositions, n);
+};
+const getSolutions = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const sols = [add(a, b).simplify(), substract(a, b).simplify()].sort((a, b) => a.evaluate() - b.evaluate());
+    return sols;
+};
+const getAnswer = (identifiers, opts) => {
+    const sols = getSolutions(identifiers);
+    if (opts?.useSetAsAnswer)
+        return new EquationSolutionNode(new DiscreteSetNode(sols)).toTex();
+    else
+        return `x=${sols[0].toTex()}\\text{ ou }x=${sols[1].toTex()}`;
+};
+const getInstruction = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    return `Factoriser, puis résoudre l'équation suivante : 
+  
+$$
+${substract(square(substract("x", a).simplify()), square(b).simplify()).toTex()} = 0
+$$`;
+};
+const getHint = () => {
+    return `Tu peux factoriser cette équation en utilisant l'identité remarquable :
+  
+$$
+a^2-b^2 = (a+b)(a-b)
+$$
+
+Ensuite, il faut résoudre une équation produit : un produit est nul si et seulement si un des deux facteurs est nul.`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    return `On commence par factoriser l'équation en utilisant l'identité remarquable : 
+  
+$$
+a^2-b^2 = (a+b)(a-b)
+$$
+  
+On a : 
+
+${alignTex([
+        [
+            substract(square(substract("x", a).simplify()), square(b).simplify()).toTex(),
+            "=",
+            "0",
+        ],
+        [
+            substract(square(substract("x", a).simplify()), square(b)).toTex(),
+            "=",
+            "0",
+        ],
+        [
+            multiply(add("x", add(opposite(a).simplify(), b)), add("x", substract(opposite(a).simplify(), b))).toTex(),
+            "=",
+            "0",
+        ],
+        [
+            multiply(add("x", add(opposite(a), b).simplify()), add("x", substract(opposite(a), b).simplify())).toTex(),
+            "=",
+            "0",
+        ],
+    ])}
+
+Un produit est nul si et seulement si un des deux facteurs est nul. On résout donc deux équations. D'une part : 
+
+$$
+${add("x", substract(b, a)).simplify().toTex()}=0
+$$
+
+ce qui donne $x=${substract(a, b).simplify().toTex()}$.
+
+D'autre part :
+
+$$
+${substract("x", add(a, b)).simplify().toTex()}=0
+$$
+
+ce qui donne $x=${add(a, b).simplify().toTex()}$. 
+
+
+Les solutions de cette équation sont donc $${substract(a, b)
+        .simplify()
+        .toTex()}$ et $${add(a, b).simplify().toTex()}$.
+`;
+};
+const getKeys = (_identifiers, options) => {
+    return options?.useSetAsAnswer
+        ? ["S", "equal", "lbrace", "semicolon", "rbrace"]
+        : ["x", "equal", "ou"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
+    try {
+        if (opts?.useSetAsAnswer) {
+            const setParsed = discreteSetParser(ans);
+            console.log(setParsed);
+            return false;
+        }
+        else {
+            const parsed = ans.split("\\text{ ou }");
+            if (parsed?.length !== 2)
+                return false;
+            const values = parsed.map((e) => e.replace("=", "").replace("x", ""));
+            const numbered = values
+                .map((v) => v.unfrenchify().toTree())
+                .sort((a, b) => a.evaluate() - b.evaluate());
+            const sols = getSolutions(identifiers);
+            if (!numberVEA(numbered[0].toTex(), sols[0].toTex()) ||
+                !numberVEA(numbered[1].toTex(), sols[1].toTex()))
+                return false;
+            return true;
+        }
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSolveByFactorizingWithIdRmq3Question = () => {
+    const a = randint(-10, 11, [0]);
+    const b = randint(1, 11);
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        bIds: b.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+// const options: GeneratorOption[] = [
+//   {
+//     id: "useSetAsAnswer",
+//     label: "Écrire la réponse sous la forme d'ensemble",
+//     target: GeneratorOptionTarget.answer,
+//     type: GeneratorOptionType.checkbox,
+//     defaultValue: false,
+//   },
+// ];
+export const solveByFactorizingWithIdRmq3 = {
+    id: "solveByFactorizingWithIdRmq3",
+    connector: "=",
+    label: "Résoudre une équation par factorisation du type $(x-a)^2 -b^2 = 0$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSolveByFactorizingWithIdRmq3Question(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    // options,
+};

package/lib/exercises/math/calculLitteral/factorisation/factoType2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factoType2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAqIF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAe5C,CAAC"}
+{"version":3,"file":"factoType2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAwBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAwJF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAe5C,CAAC"}

package/lib/exercises/math/calculLitteral/factorisation/factoType2.js

@@ -3,10 +3,14 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
-import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { isMultiplyNode, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { isPowerNode, isSquareNode, } from "../../../../tree/nodes/operators/powerNode.js";
+import { isOppositeNode } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const getPropositions = (n, { answer, a, b, c, d, isSubstract }) => {
     const propositions = [];
     const affine1 = new Affine(a, b);
@@ -64,9 +68,31 @@ ${alignTex([
 const getKeys = () => {
     return ["x"];
 };
-const isAnswerValid = (ans, { answer, a, b, c, d, isSubstract }) => {
-    const tree = getAnswerTree({ a, b, c, d, isSubstract });
-    return ans === answer || tree.toAllValidTexs().includes(ans);
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        if (answer !== "0" &&
+            !isMultiplyNode(parsed) &&
+            !isSquareNode(parsed) &&
+            !isPowerNode(parsed) &&
+            !isOppositeNode(parsed))
+            return false;
+        const simp = parsed.simplify({
+            forbidFactorize: true,
+            towardsDistribute: true,
+        });
+        const answerSimp = getAnswerTree(identifiers).simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        });
+        // const simp = parsed.simplify({});
+        return simp.toTex() === answerSimp.toTex();
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 const getFactoType2Question = () => {
     const b = randint(-10, 11);

package/lib/exercises/math/calculLitteral/factorisation/factoType3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factoType3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAyJF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAe5C,CAAC"}
+{"version":3,"file":"factoType3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAyBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AA4KF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAe5C,CAAC"}

package/lib/exercises/math/calculLitteral/factorisation/factoType3.js

@@ -3,10 +3,14 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
-import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { isMultiplyNode, multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { isPowerNode, isSquareNode, } from "../../../../tree/nodes/operators/powerNode.js";
+import { isOppositeNode } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const getPropositions = (n, { answer, a, b, c, d, k, isSubstract }) => {
     const propositions = [];
     const affine1 = new Affine(a, b);
@@ -72,9 +76,31 @@ ${alignTex([
 const getKeys = () => {
     return ["x"];
 };
-const isAnswerValid = (ans, { answer, a, b, c, d, k, isSubstract }) => {
-    const tree = getAnswerTree({ a, b, c, d, k, isSubstract });
-    return ans === answer || tree.toAllValidTexs().includes(ans);
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        if (answer !== "0" &&
+            !isMultiplyNode(parsed) &&
+            !isSquareNode(parsed) &&
+            !isPowerNode(parsed) &&
+            !isOppositeNode(parsed))
+            return false;
+        const simp = parsed.simplify({
+            forbidFactorize: true,
+            towardsDistribute: true,
+        });
+        const answerSimp = getAnswerTree(identifiers).simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        });
+        // const simp = parsed.simplify({});
+        return simp.toTex() === answerSimp.toTex();
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 const getFactoType3Question = () => {
     const b = randint(-10, 11);

package/lib/exercises/math/calculLitteral/factorisation/factoType4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factoType4.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType4.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAoKF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAe5C,CAAC"}
+{"version":3,"file":"factoType4.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType4.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AA0BrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAsLF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAe5C,CAAC"}

package/lib/exercises/math/calculLitteral/factorisation/factoType4.js

@@ -3,11 +3,14 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
-import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { isMultiplyNode, multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
-import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { isPowerNode, isSquareNode, power, } from "../../../../tree/nodes/operators/powerNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { isOppositeNode } from "../../../../tree/nodes/functions/oppositeNode.js";
 const getPropositions = (n, { answer, a, b, c, d, k, isSubstract }) => {
     const propositions = [];
     const affine1 = new Affine(a, b);
@@ -69,9 +72,31 @@ ${alignTex([
 const getKeys = () => {
     return ["x"];
 };
-const isAnswerValid = (ans, { answer, a, b, c, d, k, isSubstract }) => {
-    const tree = getAnswerTree({ a, b, c, d, k, isSubstract });
-    return ans === answer || tree.toAllValidTexs().includes(ans);
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        if (answer !== "0" &&
+            !isMultiplyNode(parsed) &&
+            !isSquareNode(parsed) &&
+            !isPowerNode(parsed) &&
+            !isOppositeNode(parsed))
+            return false;
+        const simp = parsed.simplify({
+            forbidFactorize: true,
+            towardsDistribute: true,
+        });
+        const answerSimp = getAnswerTree(identifiers).simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        });
+        // const simp = parsed.simplify({});
+        return simp.toTex() === answerSimp.toTex();
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 const getFactoType4Question = () => {
     const b = randint(-10, 11);

package/lib/exercises/math/calculLitteral/ordering/compareAMinusB.js

@@ -167,7 +167,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
 };
 export const compareAMinusB = {
     id: "compareAMinusB",
-    label: "Comparer deux nombres $a$ et $b$ par le calcul de leur différence.",
+    label: "Comparer deux nombres $a$ et $b$ par le calcul de leur différence",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getCompareAMinusBQuestion(opts), nb, 30),
     qcmTimer: 60,

package/lib/exercises/math/dataRepresentations/index.js

@@ -15,6 +15,7 @@ export * from "./graphReading.js";
 export * from "./plausibleGraph.js";
 export * from "./halfPieChartReading.js";
 export * from "./halfPieChartCommenting.js";
+// export * from "./placePointsFromDataTable.js";
 // export * from "./testGen.js";
 // export * from "./testGenGGB.js";
 // export * from "./testGenStudentGGB.js";

package/lib/exercises/math/dataRepresentations/placePointsFromDataTable.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    isRowBased: boolean;
+    rowBasedDataTable: string[][];
+    indexX: number;
+    indexY: number;
+    arrCoordsAsNodeIds: NodeIdentifiers[][];
+};
+export declare const placePointsFromDataTable: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=placePointsFromDataTable.d.ts.map

package/lib/exercises/math/dataRepresentations/placePointsFromDataTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placePointsFromDataTable.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/placePointsFromDataTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAiB7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,iBAAiB,EAAE,MAAM,EAAE,EAAE,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,eAAe,EAAE,EAAE,CAAC;CACzC,CAAC;AAyOF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAiB1D,CAAC"}