math-exercises 3.0.53 → 3.0.54

package/lib/exercises/math/calcul/mentalCaluls/mentalAddAndSub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mentalAddAndSub.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/mentalAddAndSub.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAkEF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAWjD,CAAC"}
+{"version":3,"file":"mentalAddAndSub.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/mentalAddAndSub.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA8DF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAWjD,CAAC"}

package/lib/exercises/math/calcul/mentalCaluls/mentalAddAndSub.js

@@ -1,5 +1,6 @@
 import { addValidProp, 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 { round } from "../../../../math/utils/round.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
@@ -50,11 +51,8 @@ const getPropositions = (n, { answer, numbers }) => {
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (studentAns, { numbers }) => {
-    const sum = numbers.reduce((acc, curr) => acc + curr);
-    const answerTree = new NumberNode(round(sum, 2));
-    const texs = answerTree.toAllValidTexs();
-    return texs.includes(studentAns);
+const isAnswerValid = (ans, { answer, numbers }) => {
+    return numberVEA(ans, answer);
 };
 export const mentalAddAndSub = {
     id: "mentalAddAndSub",

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

@@ -1,8 +1,13 @@
 import { Exercise } from "../../../../exercises/exercise.js";
+import { EqualNodeIdentifiers } from "../../../../tree/nodes/equations/equalNode.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
 type Identifiers = {
-    solutionNodeIds: any;
-    equationNodeIds: any;
+    solutionNodeIds: NodeIdentifiers;
+    equationNodeIds: EqualNodeIdentifiers;
 };
-export declare const binomialsTrinomialsProposedSolutions: Exercise<Identifiers>;
+type Options = {
+    degree: string;
+};
+export declare const binomialsTrinomialsProposedSolutions: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=binomialsTrinomialsProposedSolutions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"binomialsTrinomialsProposedSolutions.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/binomialsTrinomialsProposedSolutions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,GAAG,CAAC;IACrB,eAAe,EAAE,GAAG,CAAC;CACtB,CAAC;AA0EF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CAYtE,CAAC"}
+{"version":3,"file":"binomialsTrinomialsProposedSolutions.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/binomialsTrinomialsProposedSolutions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,oBAAoB,EACrB,MAAM,yCAAyC,CAAC;AACjD,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,eAAe,CAAC;IACjC,eAAe,EAAE,oBAAoB,CAAC;CACvC,CAAC;AA2FF,KAAK,OAAO,GAAG;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAYF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CACzD,WAAW,EACX,OAAO,CAiBR,CAAC"}

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

@@ -1,12 +1,21 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Affine } from "../../../../math/polynomials/affine.js";
 import { Trinom } from "../../../../math/polynomials/trinom.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { EqualNode, } from "../../../../tree/nodes/equations/equalNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
 import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
-import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
+import { substract, SubstractNode, } from "../../../../tree/nodes/operators/substractNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { solutionNodeIds, equationNodeIds } = identifiers;
+    const solution = reifyAlgebraic(solutionNodeIds, true);
+    const equation = reifyAlgebraic(equationNodeIds, true);
+    return `Le nombre $${solution.toTex()}$ est-il une solution de l'équation $${equation.toTex()}$ ?`;
+};
 function generateTrinomialFromRoot(root, constante) {
     const a = randint(1, 5);
     const r2 = randint(-10, 10, [0]);
@@ -14,61 +23,77 @@ function generateTrinomialFromRoot(root, constante) {
     const c = root * r2;
     return new Trinom(a, a * b, a * c + constante);
 }
-const getBinomialsTrinomialsProposedSolutionsQuestion = () => {
-    const degree = coinFlip();
+const getBinomialsTrinomialsProposedSolutionsQuestion = (opts) => {
+    const degree = opts?.degree === "Second degré"
+        ? 2
+        : opts?.degree === "Premier degré"
+            ? 1
+            : random([1, 2]);
     const constante = randint(-10, 10);
     const root = randint(-10, 10, [0]);
     const trinomial = generateTrinomialFromRoot(root, constante);
     const a1 = randint(-10, 10, [0]);
     const b1 = randint(-10, 10);
-    let a2;
-    do {
-        a2 = randint(-10, 10, [0]);
-    } while (a2 === a1);
+    const a2 = randint(-10, 10, [0, a1]);
     const b2 = randint(-10, 10);
     const binomial1 = new Affine(a1, b1);
     const binomial2 = new Affine(a2, b2);
-    const equation = degree
+    const equation = degree === 2
         ? new EqualNode(trinomial.toTree(), constante.toTree())
         : new EqualNode(binomial1.toTree(), binomial2.toTree());
-    const ans = degree
+    const ans = degree === 2
         ? root.toTree()
         : new FractionNode(new SubstractNode(binomial2.b.toTree(), binomial1.b.toTree()), new SubstractNode(binomial1.a.toTree(), binomial2.a.toTree())).simplify();
-    const answertype = coinFlip();
-    const solution = answertype ? ans : randint(-10, 10).toTree();
-    const answer = answertype ? "Oui" : "Non";
+    const isSol = coinFlip();
+    const solution = isSol ? ans : add(ans, randint(-2, 3, [0])).simplify();
+    const identifiers = {
+        equationNodeIds: equation.toIdentifiers(),
+        solutionNodeIds: solution.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
-        answer: answer,
-        instruction: `Le nombre $${solution.toTex()}$ est-il une solution de l'équation $${equation.toTex()}$ ?`,
-        keys: [],
+        instruction: getInstruction(identifiers, opts),
         answerFormat: "raw",
-        identifiers: {
-            equationNodeIds: equation.toIdentifiers(),
-            solutionNodeIds: solution.toIdentifiers(),
-        },
+        identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer, ...identifiers }, opts) => {
     const propositions = [];
-    addValidProp(propositions, answer, "raw");
+    const { solutionNodeIds, equationNodeIds } = identifiers;
+    const solution = reifyAlgebraic(solutionNodeIds, true);
+    const equation = reifyAlgebraic(equationNodeIds, true);
+    const allLeft = substract(equation.leftChild, equation.rightChild);
+    const ev = allLeft.toDetailedEvaluation({ x: solution }).simplify();
+    const isSol = ev.evaluate() === 0;
+    addValidProp(propositions, isSol ? "Oui" : "Non", "raw");
     tryToAddWrongProp(propositions, "Oui", "raw");
     tryToAddWrongProp(propositions, "Non", "raw");
     tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
+const options = [
+    {
+        id: "degree",
+        label: "Degré de l'équation",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        defaultValue: "Les deux",
+        values: ["Premier degré", "Second degré", "Les deux"],
+    },
+];
 export const binomialsTrinomialsProposedSolutions = {
     id: "binomialsTrinomialsProposedSolutions",
     label: "Vérifier si un nombre est solution d'une équation",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getBinomialsTrinomialsProposedSolutionsQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getBinomialsTrinomialsProposedSolutionsQuestion(opts), nb),
     answerType: "QCU",
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    options,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"multiplicationEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/multiplicationEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwHF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}
+{"version":3,"file":"multiplicationEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/multiplicationEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8HF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}

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

@@ -67,6 +67,9 @@ const getMultiplicationEquation = () => {
         d = randint(-9, 10, [0]);
     } while (a / c === b / d);
     const identifiers = { a, b, c, d };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         startStatement: getStartStatement(identifiers),

package/lib/exercises/math/calculLitteral/systems/basicNiceValuesSystemResolution.d.ts

@@ -1,7 +1,7 @@
 import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
 type Identifiers = {
-    coeffs: number[][];
-    isXAsked: boolean;
+    coeffsIds: NodeIdentifiers[][];
 };
 export declare const basicNiceValuesSystemResolution: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/calculLitteral/systems/basicNiceValuesSystemResolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"basicNiceValuesSystemResolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/basicNiceValuesSystemResolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAgDF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAcjE,CAAC"}
+{"version":3,"file":"basicNiceValuesSystemResolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/basicNiceValuesSystemResolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAKtE,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,eAAe,EAAE,EAAE,CAAC;CAIhC,CAAC;AA2EF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAgBjE,CAAC"}

package/lib/exercises/math/calculLitteral/systems/basicNiceValuesSystemResolution.js

@@ -1,44 +1,69 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { System, SystemConstructor } from "../../../../math/systems/system.js";
-import { randint } from "../../../../math/utils/random/randint.js";
-import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { Point, PointConstructor } from "../../../../math/geometry/point.js";
+import { GeneralSystemConstructor, } from "../../../../math/systems/generalSystem.js";
+import { pointParser } from "../../../../tree/parsers/pointParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 //{ a1x + b1y = c1 , a2x + b2y = c2}
-const getBasicNiceValuesSystemResolutionQuestion = () => {
-    //need a1/b1 != a2/b2
-    const sys = SystemConstructor.niceValues();
-    const { x, y } = sys.solve();
-    const isXAsked = coinFlip();
-    const variable = isXAsked ? "x" : "y";
-    const answer = isXAsked ? x.toTex() : y.toTex();
-    const question = {
-        answer,
-        instruction: `Soit le système d'équations suivant :
-  
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds?.coeffsIds?.length)
+        return oldIds;
+    return {
+        coeffsIds: oldIds.coeffs.map((row) => row.map((e) => e.toTree())),
+    };
+};
+const getInstruction = (identifiers) => {
+    const sys = GeneralSystemConstructor.fromIdentifiers(identifiers);
+    return `Résoudre le système d'équations suivant :
+
 $$
 ${sys.toTex()}
 $$
-  
-  Que vaut $${variable}$ ?`,
+
+*Donner le couple solution sous la forme $\\left(x;y\\right)$ : par exemple, si la solution est $x=2$ et $y=3$, alors on écrira $\\left(2;3\\right)$.*`;
+};
+const getAnswer = (identifiers) => {
+    const sys = GeneralSystemConstructor.fromIdentifiers(identifiers);
+    const { x, y } = sys.solve();
+    return new Point("A", x, y).toCoords();
+};
+const getBasicSystemResolutionQuestion = () => {
+    const sys = GeneralSystemConstructor.niceValues();
+    const identifiers = {
+        coeffsIds: sys.toIdentifiers().coeffsIds,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { coeffs: sys.coeffs, isXAsked },
+        identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer, coeffs, isXAsked }) => {
+const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
-    const sys = new System(coeffs);
-    const { x, y } = sys.solve();
     addValidProp(propositions, answer);
-    tryToAddWrongProp(propositions, isXAsked ? y.toTex() : x.toTex());
+    // tryToAddWrongProp(propositions, isXAsked ? y.toTex() : x.toTex());
     while (propositions.length < n) {
-        tryToAddWrongProp(propositions, randint(-10, 11) + "");
+        const point = PointConstructor.random("A");
+        tryToAddWrongProp(propositions, point.toCoords());
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, coeffs, isXAsked }) => {
-    return ans === answer;
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const parsed = pointParser(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toCoords() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const basicNiceValuesSystemResolution = {
     id: "basicNiceValuesSystemResolution",
@@ -47,10 +72,12 @@ export const basicNiceValuesSystemResolution = {
     levels: ["2nde", "1reSpé"],
     isSingleStep: true,
     sections: ["Systèmes"],
-    generator: (nb) => getDistinctQuestions(getBasicNiceValuesSystemResolutionQuestion, nb),
+    generator: (nb) => getDistinctQuestions(getBasicSystemResolutionQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    rebuildIdentifiers,
 };

package/lib/exercises/math/calculLitteral/systems/basicSystemResolution.d.ts

@@ -1,7 +1,7 @@
 import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
 type Identifiers = {
-    coeffs: number[][];
-    isXAsked: boolean;
+    coeffsIds: NodeIdentifiers[][];
 };
 export declare const basicSystemResolution: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/calculLitteral/systems/basicSystemResolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"basicSystemResolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/basicSystemResolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AA8DF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}
+{"version":3,"file":"basicSystemResolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/basicSystemResolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAKtE,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,eAAe,EAAE,EAAE,CAAC;CAIhC,CAAC;AA6EF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}

package/lib/exercises/math/calculLitteral/systems/basicSystemResolution.js

@@ -1,56 +1,71 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
-import { System, SystemConstructor } from "../../../../math/systems/system.js";
-import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { GeneralSystemConstructor, } from "../../../../math/systems/generalSystem.js";
+import { pointParser } from "../../../../tree/parsers/pointParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 //{ a1x + b1y = c1 , a2x + b2y = c2}
-const getBasicSystemResolutionQuestion = () => {
-    //need a1/b1 != a2/b2
-    const sys = SystemConstructor.random();
-    const { x, y } = sys.solve();
-    const isXAsked = coinFlip();
-    const variable = isXAsked ? "x" : "y";
-    const answer = isXAsked ? x.toTex() : y.toTex();
-    const identifiers = { coeffs: sys.coeffs, isXAsked };
-    const question = {
-        answer,
-        instruction: `Soit le système d'équations suivant :
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds?.coeffsIds?.length)
+        return oldIds;
+    return {
+        coeffsIds: oldIds.coeffs.map((row) => row.map((e) => e.toTree())),
+    };
+};
+const getInstruction = (identifiers) => {
+    const sys = GeneralSystemConstructor.fromIdentifiers(identifiers);
+    return `Résoudre le système d'équations suivant :
 
 $$
 ${sys.toTex()}
 $$
 
-Que vaut $${variable}$ ?`,
+*Donner le couple solution sous la forme $\\left(x;y\\right)$ : par exemple, si la solution est $x=2$ et $y=3$, alors on écrira $\\left(2;3\\right)$.*`;
+};
+const getAnswer = (identifiers) => {
+    const sys = GeneralSystemConstructor.fromIdentifiers(identifiers);
+    const { x, y } = sys.solve();
+    return new Point("A", x, y).toCoords();
+};
+const getBasicSystemResolutionQuestion = () => {
+    const sys = GeneralSystemConstructor.random();
+    const identifiers = {
+        coeffsIds: sys.toIdentifiers().coeffsIds,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
         identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer, coeffs, isXAsked }) => {
+const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
-    const sys = new System(coeffs);
-    const { x, y } = sys.solve();
     addValidProp(propositions, answer);
-    tryToAddWrongProp(propositions, isXAsked ? y.toTex() : x.toTex());
+    // tryToAddWrongProp(propositions, isXAsked ? y.toTex() : x.toTex());
     while (propositions.length < n) {
-        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductible().toTree().toTex());
+        const sys = GeneralSystemConstructor.random();
+        const { x, y } = sys.solve();
+        const point = new Point("A", x, y);
+        tryToAddWrongProp(propositions, point.toCoords());
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, coeffs, isXAsked }) => {
-    const sys = new System(coeffs);
-    const { x, y } = sys.solve();
-    const texs = isXAsked
-        ? x.toAllValidTexs({
-            allowFractionToDecimal: true,
-            allowMinusAnywhereInFraction: true,
-        })
-        : y.toAllValidTexs({
-            allowFractionToDecimal: true,
-            allowMinusAnywhereInFraction: true,
-        });
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const parsed = pointParser(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toCoords() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const basicSystemResolution = {
     id: "basicSystemResolution",
@@ -65,4 +80,6 @@ export const basicSystemResolution = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    rebuildIdentifiers,
 };

package/lib/exercises/math/calculLitteral/systems/verifySystemSolution.d.ts

@@ -1,6 +1,7 @@
 import { Exercise } from "../../../../exercises/exercise.js";
+import { GeneralSystemIdentifiers } from "../../../../math/systems/generalSystem.js";
 type Identifiers = {
-    sysCoeffs: number[][];
+    sysIds: GeneralSystemIdentifiers;
     x: number;
     y: number;
 };

package/lib/exercises/math/calculLitteral/systems/verifySystemSolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verifySystemSolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/verifySystemSolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8CF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"verifySystemSolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/verifySystemSolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,wBAAwB,EACzB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IAGjB,MAAM,EAAE,wBAAwB,CAAC;IACjC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}

package/lib/exercises/math/calculLitteral/systems/verifySystemSolution.js

@@ -1,49 +1,68 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { SystemConstructor } from "../../../../math/systems/system.js";
+import { GeneralSystem, GeneralSystemConstructor, } from "../../../../math/systems/generalSystem.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const rebuildIdentifiers = (oldIds) => {
+    if (!!oldIds?.sysIds)
+        return oldIds;
+    const sys = new GeneralSystem(oldIds.sysCoeffs);
+    return {
+        sysIds: sys.toIdentifiers(),
+        x: oldIds.x,
+        y: oldIds.y,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { sysIds, x, y } = identifiers;
+    const sys = GeneralSystemConstructor.fromIdentifiers(sysIds);
+    return `Soit le système d'équations suivant :
+  
+$$
+${sys.toTex()}
+$$
+    
+Le couple $(${x};${y})$ est-il une solution de ce système ?`;
+};
 const getVerifySystemSolutionQuestion = () => {
     let x;
     let y;
     const isSolution = coinFlip();
     let sys;
     if (isSolution) {
-        sys = SystemConstructor.niceValues();
+        sys = GeneralSystemConstructor.niceValues();
         const sol = sys.solve();
         x = sol.x.evaluate({});
         y = sol.y.evaluate({});
     }
     else {
-        sys = SystemConstructor.niceValues();
+        sys = GeneralSystemConstructor.niceValues();
         const sol = sys.solve();
         x = sol.x.evaluate({}) + randint(-5, 5);
         y = sol.y.evaluate({}) + randint(-5, 5, [0]);
     }
+    const identifiers = { sysIds: sys.toIdentifiers(), x, y };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: isSolution ? "Oui" : "Non",
-        instruction: `Soit le système d'équations suivant :
-  
-$${sys.toTex()}$
-    
-Le couple $(${x};${y})$ est-il une solution de ce système ?`,
-        keys: [],
+        instruction: getInstruction(identifiers),
         answerFormat: "raw",
-        identifiers: { sysCoeffs: sys.coeffs, x, y },
+        identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
-    addValidProp(propositions, answer, "raw");
+    const { sysIds, x, y } = identifiers;
+    const sys = GeneralSystemConstructor.fromIdentifiers(sysIds);
+    const isSol = sys.checkCouple(x.toTree(), y.toTree());
+    addValidProp(propositions, isSol ? "Oui" : "Non", "raw");
     tryToAddWrongProp(propositions, "Oui", "raw");
     tryToAddWrongProp(propositions, "Non", "raw");
     tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const verifySystemSolution = {
     id: "verifySystemSolution",
     label: "Vérifier si un couple est solution d'un système",
@@ -54,7 +73,8 @@ export const verifySystemSolution = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
     answerType: "QCU",
+    getQuestionFromIdentifiers,
+    rebuildIdentifiers,
 };

package/lib/exercises/math/geometry/angles/recognizeAngleType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognizeAngleType.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/recognizeAngleType.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAWtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA8TF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAkBpD,CAAC"}
+{"version":3,"file":"recognizeAngleType.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/recognizeAngleType.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAWtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAmVF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAkBpD,CAAC"}

package/lib/exercises/math/geometry/angles/recognizeAngleType.js

@@ -8,7 +8,6 @@ import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { random } from "../../../../utils/alea/random.js";
-import { isLetter } from "../../../../utils/strings/isLetter.js";
 import { randomLetter } from "../../../../utils/strings/randomLetter.js";
 const getAngle = (identifiers) => {
     const indexes = getAnglePointsIndexes(identifiers.angleIndex, identifiers.apexIndex);
@@ -168,25 +167,47 @@ const isAnswerValid = (ans, { answer, angleIndex, angleType, apexIndex, points }
     if (ans.includes("widehat")) {
         formated = formated.replaceAll("\\widehat{", "").replaceAll("}", "");
     }
-    const pointsNames = Array.from(new Set(formated.split("")));
-    if (pointsNames.length !== 3 || pointsNames.some((char) => !isLetter(char)))
-        return false;
-    const studentPoints = pointsNames.map((char) => PointConstructor.fromIdentifiers(points.find((p) => p.name === char)));
-    const answerAngle = getAngle({ angleIndex, apexIndex, points });
-    const studentAngle = new Angle(studentPoints);
-    //? on va accpter aussi des angles correspondants ou alternes-internes qui ne sont pas définis par les sécantes tracées
-    //? c'est chelou mais dans le fond ça fait sens (c'est vrai mathémtiquement)
+    //TODO fix vea
+    return "\\widehat{" + formated + "}" === answer;
+    let validAngles = [answer];
     switch (angleType) {
         case "opposé par le sommet":
-            return studentAngle.isSummitOpposite(answerAngle);
+        // return studentAngle.isSummitOpposite(answerAngle);
         case "alterne-interne":
-            return studentAngle.isAlterneInterne(answerAngle);
+            // return studentAngle.isAlterneInterne(answerAngle);
             break;
         case "correspondant":
         default:
-            return studentAngle.isCorrespondant(answerAngle);
+            // return studentAngle.isCorrespondant(answerAngle);
             break;
     }
+    return validAngles.includes(formated);
+    // console.log(angleIndex, angleType, apexIndex);
+    // let formated = ans;
+    // if (ans.includes("widehat")) {
+    //   formated = formated.replaceAll("\\widehat{", "").replaceAll("}", "");
+    // }
+    // const pointsNames = Array.from(new Set(formated.split("")));
+    // if (pointsNames.length !== 3 || pointsNames.some((char) => !isLetter(char)))
+    //   return false;
+    // const studentPoints = pointsNames.map((char) =>
+    //   PointConstructor.fromIdentifiers(points.find((p) => p.name === char)!),
+    // );
+    // const answerAngle = getAngle({ angleIndex, apexIndex, points });
+    // const studentAngle = new Angle(studentPoints);
+    // //? on va accpter aussi des angles correspondants ou alternes-internes qui ne sont pas définis par les sécantes tracées
+    // //? c'est chelou mais dans le fond ça fait sens (c'est vrai mathémtiquement)
+    // switch (angleType) {
+    //   case "opposé par le sommet":
+    //     return studentAngle.isSummitOpposite(answerAngle);
+    //   case "alterne-interne":
+    //     return studentAngle.isAlterneInterne(answerAngle);
+    //     break;
+    //   case "correspondant":
+    //   default:
+    //     return studentAngle.isCorrespondant(answerAngle);
+    //     break;
+    // }
     return false;
 };
 //deux paires de sécantes