math-exercises 3.0.30 → 3.0.32

package/lib/exercises/math/calcul/arithmetics/euclideanDivision.js

@@ -17,7 +17,7 @@ const getEuclideanDivisionQuestions = () => {
     const answer = new EqualNode(new NumberNode(dividend), new AddNode(new MultiplyNode(new NumberNode(divisor), new NumberNode(quotient)), new NumberNode(remainder)));
     const answerTex = answer.toTex();
     const question = {
-        instruction: `Ecrire la division euclidienne de $${dividend}$ par $${divisor}$.`,
+        instruction: `Écrire la division euclidienne de $${dividend}$ par $${divisor}$.`,
         answer: answerTex,
         keys: ["equal"],
         answerFormat: "tex",
@@ -45,7 +45,7 @@ const getPropositions = (n, { answer, dividend }) => {
 export const euclideanDivision = {
     id: "euclideanDivision",
     connector: "=",
-    label: "Ecrire une division euclidienne",
+    label: "Écrire une division euclidienne",
     levels: ["6ème", "5ème", "4ème"],
     sections: ["Arithmétique"],
     isSingleStep: true,

package/lib/exercises/math/calcul/fractions/fractionsProduct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fractionsProduct.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsProduct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAiIF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqB3D,CAAC"}
+{"version":3,"file":"fractionsProduct.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsProduct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAiIF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmB3D,CAAC"}

package/lib/exercises/math/calcul/fractions/fractionsProduct.js

@@ -62,7 +62,7 @@ const getFractionsProduct = (opts) => {
         rationalNum: [rational.num, rational.denum],
         rationalDenum: [rational2.num, rational2.denum],
     };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
 const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
@@ -108,8 +108,6 @@ export const fractionsProduct = {
     id: "fractionsProduct",
     connector: "=",
     label: "Produits de fractions",
-    levels: ["4ème", "3ème", "2nde", "CAP", "2ndPro", "1rePro"],
-    sections: ["Fractions"],
     isSingleStep: false,
     generator: (nb, opts) => getDistinctQuestions(() => getFractionsProduct(opts), nb),
     qcmTimer: 60,

package/lib/exercises/math/calcul/fractions/fractionsSubstraction.js

@@ -52,7 +52,7 @@ const isAnswerValid = (ans, { answer }, opts) => {
             const parsed = rationalParser(ans);
             if (!parsed)
                 return false;
-            return parsed.simplify().toTex() === answer;
+            return parsed.simplify({ decimalToFractions: true }).toTex() === answer;
         }
         else {
             return ans === answer;
@@ -72,7 +72,7 @@ const getFractionsSubstractionQuestion = (opts) => {
         frac1: [ratio1.num, ratio1.denum],
         frac2: [ratio2.num, ratio2.denum],
     };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
 const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {

package/lib/exercises/math/calcul/fractions/fractionsSumsPrimeDenominators.js

@@ -74,7 +74,7 @@ const options = [
 export const fractionsSumsPrimeDenominators = {
     id: "fractionsSumsPrimeDenominators",
     connector: "=",
-    label: "Sommes de fractions (dénominateurs premiers entre eux)",
+    label: "Sommes de fractions (avec dénominateurs premiers entre eux)",
     levels: [],
     isSingleStep: true,
     sections: [],

package/lib/exercises/math/calcul/fractions/fractionsSumsSameDenominators.js

@@ -101,7 +101,7 @@ const options = [
 export const fractionsSumsSameDenominators = {
     id: "fractionsSumsSameDenominators",
     connector: "=",
-    label: "Sommes de fractions (avec même dénominateurs)",
+    label: "Sommes de fractions (avec même dénominateur)",
     levels: [],
     isSingleStep: true,
     sections: [],

package/lib/exercises/math/calcul/fractions/periodicWritingToFraction.js

@@ -34,7 +34,7 @@ const getPeriodicWritingToFractionQuestion = () => {
         .toTex();
     const question = {
         answer,
-        instruction: `Ecrire sous forme de fraction : $${x}$`,
+        instruction: `Écrire sous forme de fraction : $${x}$`,
         keys: [],
         answerFormat: "tex",
         identifiers: { num, denum, leadingPart: leadingPart.value },

package/lib/exercises/math/calcul/fractions/simplifyFraction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simplifyFraction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/simplifyFraction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAqDF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAalD,CAAC"}
+{"version":3,"file":"simplifyFraction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/simplifyFraction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgEF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAWlD,CAAC"}

package/lib/exercises/math/calcul/fractions/simplifyFraction.js

@@ -1,25 +1,36 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Rational, RationalConstructor, } from "../../../../math/numbers/rationals/rational.js";
-import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getStatementNode = (identifiers) => {
+    const { num, denum } = identifiers;
+    const rational = new Rational(num, denum).toTree();
+    return rational;
+};
+const getStartStatement = (identifiers) => {
+    const rationalTex = getStatementNode(identifiers).toTex();
+    return rationalTex;
+};
 const getInstruction = (identifiers) => {
-    const rational = frac(identifiers.num, identifiers.denum);
     return `Simplifier le plus possible : 
   
 $$
-${rational.toTex()}
+${getStartStatement(identifiers)}
 $$`;
 };
+const getAnswer = (identifiers) => {
+    const { num, denum } = identifiers;
+    const rational = new Rational(num, denum);
+    const answer = rational.simplify().toTree().toTex();
+    return answer;
+};
 const getSimplifyFraction = () => {
     const rational = RationalConstructor.randomSimplifiable(10);
-    const rationalTex = rational.toTree().toTex();
-    const answer = rational.simplify().toTree().toTex();
     const identifiers = { num: rational.num, denum: rational.denum };
     const question = {
         instruction: getInstruction(identifiers),
-        startStatement: rationalTex,
-        answer,
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
         keys: [],
         answerFormat: "tex",
         identifiers,
@@ -46,9 +57,7 @@ const isAnswerValid = (ans, { num, denum }) => {
 export const simplifyFraction = {
     id: "simplifyFrac",
     connector: "=",
-    label: "Simplification de fractions",
-    levels: ["4ème", "3ème", "2nde", "CAP", "2ndPro", "1rePro"],
-    sections: ["Fractions"],
+    label: "Simplifier une fraction",
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getSimplifyFraction, nb),
     qcmTimer: 60,

package/lib/exercises/math/calculLitteral/distributivity/allIdentities.js

@@ -1,8 +1,8 @@
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { random } from "../../../../utils/alea/random.js";
-import { getFirstIdentityPropositions, getFirstIdentityQuestion, isFirstIdentityAnswerValid, } from "./firstIdentity.js";
-import { getSecondIdentityPropositions, getSecondIdentityQuestion, isSecondIdentityAnswerValid, } from "./secondIdentity.js";
-import { getThirdIdentityPropositions, getThirdIdentityQuestion, isThirdIdentityAnswerValid, } from "./thirdIdentity.js";
+import { getFirstIdentityPropositions, getFirstIdentityQuestion, isFirstIdentityAnswerValid, } from "./idRmq1.js";
+import { getSecondIdentityPropositions, getSecondIdentityQuestion, isSecondIdentityAnswerValid, } from "./idRmq2.js";
+import { getThirdIdentityPropositions, getThirdIdentityQuestion, isThirdIdentityAnswerValid, } from "./idRmq3.js";
 const getAllIdentitiesQuestion = () => {
     const type = random([1, 2, 3]);
     let question;

package/lib/exercises/math/calculLitteral/distributivity/doubleDistri.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    affine1Coeffs: number[];
+    affine2Coeffs: number[];
+};
+export declare const doubleDistributivity: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=doubleDistri.d.ts.map

package/lib/exercises/math/calculLitteral/distributivity/doubleDistri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doubleDistri.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/doubleDistri.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AA+JF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAmBtD,CAAC"}

package/lib/exercises/math/calculLitteral/distributivity/doubleDistri.js

@@ -0,0 +1,155 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+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 { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { polynomialParser } from "../../../../tree/parsers/polynomialParser.js";
+const getStatementNode = (identifiers) => {
+    const { affine1Coeffs, affine2Coeffs } = identifiers;
+    const affines = [
+        new Affine(affine1Coeffs[1], affine1Coeffs[0]),
+        new Affine(affine2Coeffs[1], affine2Coeffs[0]),
+    ];
+    const statementTree = new MultiplyNode(affines[0].toTree(), affines[1].toTree());
+    return statementTree;
+};
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    return `Développer et réduire : 
+  
+$$
+${getStartStatement(identifiers)}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { affine1Coeffs, affine2Coeffs } = identifiers;
+    const affines = [
+        new Affine(affine1Coeffs[1], affine1Coeffs[0]),
+        new Affine(affine2Coeffs[1], affine2Coeffs[0]),
+    ];
+    const answer = affines[0].multiply(affines[1]).toTree().toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    return "Multiplie chaque terme du premier facteur par chaque terme du second facteur, puis regroupe les termes similaires.";
+};
+const getCorrection = (identifiers) => {
+    const statementTex = getStartStatement(identifiers);
+    const answer = getAnswer(identifiers);
+    const { affine1Coeffs, affine2Coeffs } = identifiers;
+    const affines = [
+        new Affine(affine1Coeffs[1], affine1Coeffs[0]),
+        new Affine(affine2Coeffs[1], affine2Coeffs[0]),
+    ];
+    const subTerms = [
+        new MultiplyNode(affines[0].a.toTree(), "x".toTree()),
+        affines[0].b.toTree(),
+        new MultiplyNode(affines[1].a.toTree(), "x".toTree()),
+        affines[1].b.toTree(),
+    ];
+    const subMultiplications = [
+        new MultiplyNode(subTerms[0], subTerms[2], { forceTimesSign: true }),
+        new MultiplyNode(subTerms[0], subTerms[3], { forceTimesSign: true }),
+        new MultiplyNode(subTerms[1], subTerms[2], { forceTimesSign: true }),
+        new MultiplyNode(subTerms[1], subTerms[3], { forceTimesSign: true }),
+    ];
+    return `
+${alignTex([
+        [statementTex, "=", operatorComposition(AddNode, subMultiplications).toTex()],
+        [
+            "",
+            "=",
+            operatorComposition(AddNode, subMultiplications.map((e) => e.simplify())).toTex(),
+        ],
+        ["", "=", answer],
+    ])}
+
+    `;
+};
+const getDoubleDistributivityQuestion = () => {
+    const affines = AffineConstructor.differentRandoms(2, undefined, {
+        excludes: [0],
+    });
+    const statementTree = new MultiplyNode(affines[0].toTree(), affines[1].toTree());
+    const identifiers = {
+        affine1Coeffs: affines[0].coefficients,
+        affine2Coeffs: affines[1].coefficients,
+    };
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: statementTree.toTex(),
+        answer: getAnswer(identifiers),
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, affine1Coeffs, affine2Coeffs }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const affines = [
+        new Affine(affine1Coeffs[1], affine1Coeffs[0]),
+        new Affine(affine2Coeffs[1], affine2Coeffs[0]),
+    ];
+    tryToAddWrongProp(propositions, affines[0]
+        .multiply(new Affine(-affines[1].a, randint(-9, 10, [affines[1].b])))
+        .toTree()
+        .toTex());
+    tryToAddWrongProp(propositions, affines[1]
+        .multiply(new Affine(randint(-9, 10, [affines[0].a, 0]), affines[0].b))
+        .toTree()
+        .toTex());
+    while (propositions.length < n) {
+        const affinesTemps = AffineConstructor.differentRandoms(2, undefined, {
+            excludes: [0],
+        });
+        const wrongAnswer = affinesTemps[0].multiply(affinesTemps[1]).toTree();
+        tryToAddWrongProp(propositions, wrongAnswer.toTex());
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = polynomialParser(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({
+            forbidFactorize: true,
+            towardsDistribute: true,
+        })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const doubleDistributivity = {
+    id: "doubleDistri",
+    connector: "=",
+    label: "Distributivité double",
+    levels: ["3ème", "2nde", "1reTech"],
+    sections: ["Calcul littéral"],
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getDoubleDistributivityQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getInstruction,
+    getAnswer,
+    getCorrection,
+    getHint,
+};

package/lib/exercises/math/calculLitteral/distributivity/idRmq1.d.ts

@@ -0,0 +1,11 @@
+import { Exercise, QCMGenerator, QuestionGenerator, VEA } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+};
+export declare const getFirstIdentityQuestion: QuestionGenerator<Identifiers>;
+export declare const getFirstIdentityPropositions: QCMGenerator<Identifiers>;
+export declare const isFirstIdentityAnswerValid: VEA<Identifiers>;
+export declare const firstIdentity: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=idRmq1.d.ts.map

package/lib/exercises/math/calculLitteral/distributivity/idRmq1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idRmq1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/idRmq1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAOR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2EF,eAAO,MAAM,wBAAwB,EAAE,iBAAiB,CAAC,WAAW,CAwBnE,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,YAAY,CAAC,WAAW,CAkClE,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,GAAG,CAAC,WAAW,CAgBvD,CAAC;AAMF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAmB/C,CAAC"}

package/lib/exercises/math/calculLitteral/distributivity/idRmq1.js

@@ -0,0 +1,147 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { AddNode, isAddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { PowerNode, SquareNode } from "../../../../tree/nodes/operators/powerNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { isSubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
+const getStatementNode = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Affine(a, b);
+    const statementTree = new PowerNode(affine.toTree(), new NumberNode(2));
+    return statementTree;
+};
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    return `Développer et réduire : 
+  
+$$
+${getStartStatement(identifiers)}
+$$`;
+};
+const getHint = (identifiers) => {
+    const affine = new Affine(identifiers.a, identifiers.b);
+    const aMonom = new MultiplyNode(affine.a.toTree(), "x".toTree());
+    return `Utilise l'identité remarquable :
+    
+$$
+(a+b)^2 = a^2 + 2ab+b^2
+$$ 
+
+en prenant $a=${aMonom.toTex()}$ et $b=${affine.b}$.`;
+};
+const getCorrection = (identifiers) => {
+    const affine = new Affine(identifiers.a, identifiers.b);
+    const statementTex = getStartStatement(identifiers);
+    const answer = getAnswer(identifiers);
+    const aMonom = new MultiplyNode(affine.a.toTree(), "x".toTree());
+    return `On utilise l'identité remarquable :
+
+$$
+(a+b)^2 = a^2 + 2ab+b^2
+$$ 
+
+en prenant $a=${aMonom.toTex()}$ et $b=${affine.b}$.
+
+Cela donne donc : 
+
+${alignTex([
+        [
+            statementTex,
+            "=",
+            new AddNode(new AddNode(new SquareNode(aMonom), new MultiplyNode((2).toTree(), new MultiplyNode(aMonom, affine.b.toTree()))), new SquareNode(affine.b.toTree())).toTex(),
+        ],
+        ["", "=", answer],
+    ])}
+`;
+};
+const getAnswer = (identifiers) => {
+    const affine = new Affine(identifiers.a, identifiers.b);
+    const answer = affine.multiply(affine).toTree().toTex();
+    return answer;
+};
+export const getFirstIdentityQuestion = () => {
+    const affine = AffineConstructor.random({
+        min: 1,
+        max: 11,
+    }, {
+        min: 1,
+        max: 11,
+    });
+    const identifiers = { a: affine.a, b: affine.b };
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const getFirstIdentityPropositions = (n, { answer, a, b }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, new Polynomial([b ** 2, 0, a ** 2]).toTree().toTex());
+    tryToAddWrongProp(propositions, new Polynomial([b ** 2, a * b, a ** 2]).toTree().toTex());
+    tryToAddWrongProp(propositions, new Polynomial([b ** 2, a ** 2 + b ** 2, a ** 2]).toTree().toTex());
+    const affine = new Affine(a, b);
+    while (propositions.length < n) {
+        const affineTemp = AffineConstructor.random({
+            excludes: [0],
+        }, {
+            excludes: [0],
+        });
+        const wrongAnswer = affine.multiply(affineTemp).toTree();
+        tryToAddWrongProp(propositions, wrongAnswer.toTex());
+    }
+    return shuffle(propositions);
+};
+export const isFirstIdentityAnswerValid = (ans, { answer, a, b }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        if (!isAddNode(parsed) && !isSubstractNode(parsed))
+            return false;
+        return (parsed
+            .simplify({ forbidFactorize: true, towardsDistribute: true })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const tests = () => {
+    //si identifiers = x,y alors questions devrait etre x,y et vea devrait accepter x,y,z
+};
+export const firstIdentity = {
+    id: "idRmq1",
+    connector: "=",
+    label: "Identité remarquable $(a+b)^2$",
+    levels: ["3ème", "2nde"],
+    sections: ["Calcul littéral"],
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getFirstIdentityQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions: getFirstIdentityPropositions,
+    isAnswerValid: isFirstIdentityAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getAnswer,
+    getInstruction,
+    getCorrection,
+    getHint,
+    getStartStatement,
+};

package/lib/exercises/math/calculLitteral/distributivity/idRmq2.d.ts

@@ -0,0 +1,11 @@
+import { Exercise, QCMGenerator, QuestionGenerator, VEA } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+};
+export declare const getSecondIdentityQuestion: QuestionGenerator<Identifiers>;
+export declare const getSecondIdentityPropositions: QCMGenerator<Identifiers>;
+export declare const isSecondIdentityAnswerValid: VEA<Identifiers>;
+export declare const secondIdentity: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=idRmq2.d.ts.map

package/lib/exercises/math/calculLitteral/distributivity/idRmq2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idRmq2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/idRmq2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAOR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiFF,eAAO,MAAM,yBAAyB,EAAE,iBAAiB,CAAC,WAAW,CAuBpE,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,YAAY,CAAC,WAAW,CAqCnE,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,GAAG,CAAC,WAAW,CAgBxD,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAkBhD,CAAC"}

package/lib/exercises/math/calculLitteral/distributivity/idRmq2.js

@@ -0,0 +1,150 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { AddNode, isAddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { PowerNode, SquareNode } from "../../../../tree/nodes/operators/powerNode.js";
+import { SubstractNode, isSubstractNode, } from "../../../../tree/nodes/operators/substractNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getStatementNode = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Affine(a, b);
+    const statementTree = new PowerNode(affine.toTree(), new NumberNode(2));
+    return statementTree;
+};
+const getStartStatement = (identifiers) => {
+    const statementTree = getStatementNode(identifiers);
+    const statementTex = statementTree.toTex();
+    return statementTex;
+};
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Développer et réduire : 
+
+$$
+${getStartStatement(identifiers)}
+$$`;
+};
+const getHint = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Affine(a, b);
+    const aMonom = new MultiplyNode(affine.a.toTree(), "x".toTree());
+    const bPositive = -affine.b;
+    return `Utilise l'identité remarquable 
+
+$$
+(a-b)^2 = a^2 - 2ab+b^2
+$$
+
+en prenant $a=${aMonom.toTex()}$ et $b=${bPositive}$`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Affine(a, b);
+    const answer = affine.multiply(affine).toTree().toTex();
+    return answer;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Affine(a, b);
+    const aMonom = new MultiplyNode(affine.a.toTree(), "x".toTree());
+    const bPositive = -affine.b;
+    const statementTex = getStartStatement(identifiers);
+    const answer = getAnswer(identifiers);
+    return `On utilise l'identité remarquable 
+
+$$
+(a-b)^2 = a^2 - 2ab+b^2
+$$
+
+en prenant $a=${aMonom.toTex()}$ et $b=${bPositive}$ : 
+
+${alignTex([
+        [
+            statementTex,
+            "=",
+            new AddNode(new SubstractNode(new SquareNode(aMonom), new MultiplyNode((2).toTree(), new MultiplyNode(aMonom, bPositive.toTree()))), new SquareNode(bPositive.toTree())).toTex(),
+        ],
+        ["", "=", answer],
+    ])}
+`;
+};
+export const getSecondIdentityQuestion = () => {
+    const affine = AffineConstructor.random({
+        min: 1,
+        max: 11,
+    }, {
+        min: -10,
+        max: 0,
+    });
+    const identifiers = { a: affine.a, b: affine.b };
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const getSecondIdentityPropositions = (n, { answer, a, b }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, new Polynomial([-(b ** 2), 0, a ** 2]).toTree().toTex());
+    tryToAddWrongProp(propositions, new Polynomial([b ** 2, a * b, a ** 2]).toTree().toTex());
+    tryToAddWrongProp(propositions, new Polynomial([-(b ** 2), -(a ** 2 + b ** 2), a ** 2]).toTree().toTex());
+    const affine = new Affine(a, b);
+    while (propositions.length < n) {
+        const affineTemp = AffineConstructor.random({
+            min: 1,
+            max: 11,
+        }, {
+            min: -10,
+            max: 0,
+        });
+        const wrongAnswer = affine.multiply(affineTemp).toTree();
+        tryToAddWrongProp(propositions, wrongAnswer.toTex());
+    }
+    return shuffle(propositions);
+};
+export const isSecondIdentityAnswerValid = (ans, { a, b, answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        if (!isAddNode(parsed) && !isSubstractNode(parsed))
+            return false;
+        return (parsed
+            .simplify({ forbidFactorize: true, towardsDistribute: true })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const secondIdentity = {
+    id: "idRmq2",
+    connector: "=",
+    label: "Identité remarquable $(a-b)^2$",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getSecondIdentityQuestion, nb),
+    getPropositions: getSecondIdentityPropositions,
+    isAnswerValid: isSecondIdentityAnswerValid,
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getInstruction,
+    getCorrection,
+    getHint,
+    getAnswer,
+    getStartStatement,
+};