math-exercises 3.0.30 → 3.0.32

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

@@ -0,0 +1,11 @@
+import { Exercise, QCMGenerator, QuestionGenerator, VEA } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    affine1Coeffs: number[];
+    affine2Coeffs: number[];
+};
+export declare const getThirdIdentityQuestion: QuestionGenerator<Identifiers>;
+export declare const getThirdIdentityPropositions: QCMGenerator<Identifiers>;
+export declare const isThirdIdentityAnswerValid: VEA<Identifiers>;
+export declare const thirdIdentity: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=idRmq3.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"idRmq3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/idRmq3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAOR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAoEF,eAAO,MAAM,wBAAwB,EAAE,iBAAiB,CAAC,WAAW,CAkBnE,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,YAAY,CAAC,WAAW,CA2BlE,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,GAAG,CAAC,WAAW,CAgBvD,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAiB/C,CAAC"}

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

@@ -0,0 +1,143 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { 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 { isAddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getStatementNode = (identifiers) => {
+    const { affine1Coeffs, affine2Coeffs } = identifiers;
+    const affine = new Affine(affine1Coeffs[1], affine1Coeffs[0]);
+    const affine2 = new Affine(affine2Coeffs[1], affine2Coeffs[0]);
+    const statementTree = new MultiplyNode(affine.toTree(), affine2.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 affine = new Affine(affine1Coeffs[1], affine1Coeffs[0]);
+    const affine2 = new Affine(affine2Coeffs[1], affine2Coeffs[0]);
+    const answer = affine.multiply(affine2).toTree().toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { affine1Coeffs, affine2Coeffs } = identifiers;
+    const affine = new Affine(affine1Coeffs[1], affine1Coeffs[0]);
+    const aMonom = new MultiplyNode(affine.a.toTree(), "x".toTree());
+    const bPositive = Math.abs(affine.b);
+    return `Utilise l'identité remarquable 
+    
+$$
+(a-b)(a+b) = a^2 - b^2
+$$ 
+
+en prenant $a=${aMonom.toTex()}$ et $b=${bPositive}$`;
+};
+const getCorrection = (identifiers) => {
+    const { affine1Coeffs, affine2Coeffs } = identifiers;
+    const affine = new Affine(affine1Coeffs[1], affine1Coeffs[0]);
+    const aMonom = new MultiplyNode(affine.a.toTree(), "x".toTree());
+    const bPositive = Math.abs(affine.b);
+    const statementTex = getStartStatement(identifiers);
+    const answer = getAnswer(identifiers);
+    return `
+On utilise l'identité remarquable 
+
+$$
+(a-b)(a+b) = a^2 - b^2
+$$ 
+
+en prenant $a=${aMonom.toTex()}$ et $b=${bPositive}$.
+
+${alignTex([
+        [
+            statementTex,
+            "=",
+            new SubstractNode(new SquareNode(aMonom), new SquareNode(bPositive.toTree())).toTex(),
+        ],
+        ["", "=", answer],
+    ])}`;
+};
+export const getThirdIdentityQuestion = () => {
+    const affine = AffineConstructor.random(undefined, { excludes: [0] });
+    const affine2 = new Affine(affine.a, -affine.b);
+    const identifiers = {
+        affine1Coeffs: affine.coefficients,
+        affine2Coeffs: affine2.coefficients,
+    };
+    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 getThirdIdentityPropositions = (n, { answer, affine1Coeffs, affine2Coeffs }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const affine = new Affine(affine1Coeffs[1], affine1Coeffs[0]);
+    const affine2 = new Affine(affine2Coeffs[1], affine2Coeffs[0]);
+    tryToAddWrongProp(propositions, affine.multiply(affine2.opposite()).toTree().toTex());
+    tryToAddWrongProp(propositions, affine.multiply(affine).toTree().toTex());
+    tryToAddWrongProp(propositions, affine2.multiply(affine2.opposite()).toTree().toTex());
+    while (propositions.length < n) {
+        const affineTemp = AffineConstructor.random(undefined, {
+            excludes: [0],
+        });
+        const affineTemp2 = new Affine(affineTemp.a, -affineTemp.b);
+        const wrongAnswer = affineTemp.multiply(affineTemp2).toTree();
+        tryToAddWrongProp(propositions, wrongAnswer.toTex());
+    }
+    return shuffle(propositions);
+};
+export const isThirdIdentityAnswerValid = (ans, { answer, affine1Coeffs, affine2Coeffs }) => {
+    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 thirdIdentity = {
+    id: "idRmq3",
+    connector: "=",
+    label: "Identité remarquable $(a+b)(a-b)$",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getThirdIdentityQuestion, nb),
+    getPropositions: getThirdIdentityPropositions,
+    isAnswerValid: isThirdIdentityAnswerValid,
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getInstruction,
+    getCorrection,
+    getHint,
+    getAnswer,
+    getStartStatement,
+};

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

@@ -1,9 +1,9 @@
 export * from "./allIdentities.js";
-export * from "./doubleDistributivity.js";
-export { firstIdentity } from "./firstIdentity.js";
-export { secondIdentity } from "./secondIdentity.js";
+export * from "./doubleDistri.js";
+export { firstIdentity } from "./idRmq1.js";
+export { secondIdentity } from "./idRmq2.js";
 export * from "./simpleDistri.js";
-export { thirdIdentity } from "./thirdIdentity.js";
+export { thirdIdentity } from "./idRmq3.js";
 export * from "./doubleDistributivityWithCoeff.js";
 export * from "./canonicalFormDevelopment.js";
 export * from "./simpleDistriXCoeff.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,cAAc,oCAAoC,CAAC;AACnD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC;AACnD,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC;AACnD,cAAc,gCAAgC,CAAC"}

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

@@ -1,9 +1,9 @@
 export * from "./allIdentities.js";
-export * from "./doubleDistributivity.js";
-export { firstIdentity } from "./firstIdentity.js";
-export { secondIdentity } from "./secondIdentity.js";
+export * from "./doubleDistri.js";
+export { firstIdentity } from "./idRmq1.js";
+export { secondIdentity } from "./idRmq2.js";
 export * from "./simpleDistri.js";
-export { thirdIdentity } from "./thirdIdentity.js";
+export { thirdIdentity } from "./idRmq3.js";
 export * from "./doubleDistributivityWithCoeff.js";
 export * from "./canonicalFormDevelopment.js";
 export * from "./simpleDistriXCoeff.js";

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

@@ -1 +1 @@
-{"version":3,"file":"simpleDistriXCoeff.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/simpleDistriXCoeff.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8GF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAiBpD,CAAC"}
+{"version":3,"file":"simpleDistriXCoeff.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/simpleDistriXCoeff.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8GF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAkBpD,CAAC"}

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

@@ -105,6 +105,7 @@ export const simpleDistriXCoeff = {
     subject: "Mathématiques",
     getHint,
     getCorrection,
+    getInstruction,
     getAnswer,
     hasHintAndCorrection: true,
 };

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+/**
+ *  type x+a=b
+ */
+type Identifiers = {
+    a: number;
+    b: number;
+};
+export declare const equationType1Exercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=equa1.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"equa1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equa1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAqBvD,CAAC"}

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

@@ -0,0 +1,111 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { equationKeys } from "../../../../exercises/utils/keys/equationKeys.js";
+import { Affine } from "../../../../math/polynomials/affine.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { equationVEA } from "../../../../exercises/vea/equationVEA.js";
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Affine(1, a).toTree();
+    const tree = new EqualNode(affine, new NumberNode(b));
+    const statementTree = tree.toTex();
+    return `Résoudre : 
+  
+$$
+${statementTree}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    const solution = b - a;
+    const answer = `x=${solution}`;
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Il faut isoler $x$ à gauche. Pour cela, effectue l'opération des deux côtés de l'équation qui permet de supprimer le terme $${a < 0 ? "" : "+"}${a}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Affine(1, a).toTree();
+    const tree = new EqualNode(affine, new NumberNode(b));
+    const statementTree = tree.toTex();
+    const answer = getAnswer(identifiers);
+    return `Pour isoler $x$ à gauche, on effectue l'opération $${a > 0 ? `-${a}` : `+${Math.abs(a)}`}$ des deux côtés de l'équation : 
+    
+${alignTex([
+        [
+            `${statementTree}`,
+            "\\iff",
+            new EqualNode(new AddNode(affine, new NumberNode(-a)), new AddNode(b.toTree(), new NumberNode(-a))).toTex(),
+        ],
+        ["", "\\iff", answer],
+    ])}`;
+};
+const getStartStatement = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Affine(1, a).toTree();
+    const tree = new EqualNode(affine, new NumberNode(b));
+    const statementTree = tree.toTex();
+    return statementTree;
+};
+const getEquationType1ExerciseQuestion = () => {
+    const b = randint(-10, 11);
+    const a = randint(-10, 11, [0]);
+    const identifiers = { a, b };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
+        keys: equationKeys,
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const solution = b - a;
+    tryToAddWrongProp(propositions, `x=${b + a}`);
+    while (propositions.length < n) {
+        const wrongAnswer = solution + randint(-3, 4, [0]);
+        tryToAddWrongProp(propositions, `x=${wrongAnswer}`);
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { a, b }) => {
+    const solution = (b - a).toTree().toTex();
+    return equationVEA(ans, solution);
+};
+export const equationType1Exercise = {
+    id: "equa1",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $x+a = b$",
+    levels: ["4ème", "3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
+    sections: ["Équations"],
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getEquationType1ExerciseQuestion, nb),
+    getPropositions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getCorrection,
+    getHint,
+    getInstruction,
+    getAnswer,
+    getStartStatement,
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,17 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+/**
+ *  type ax=b
+ */
+type Identifiers = {
+    a: NodeIdentifiers;
+    b: NodeIdentifiers;
+    isXRight: boolean;
+    aNumberType: string;
+};
+type Options = {
+    aNumberType: string[];
+};
+export declare const equationType2Exercise: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=equa2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"equa2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equa2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAsBrC,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C;;GAEG;AAGH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA0JF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAaF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuBhE,CAAC"}

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

@@ -0,0 +1,164 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { equationKeys } from "../../../../exercises/utils/keys/equationKeys.js";
+import { RationalConstructor, } from "../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EqualNode, equal } from "../../../../tree/nodes/equations/equalNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { GeneralAffine } from "../../../../math/polynomials/generalAffine.js";
+import { NodeConstructor, reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { equationVEA } from "../../../../exercises/vea/equationVEA.js";
+const rebuildIdentifiers = (oldIdentifiers) => {
+    if (!!oldIdentifiers.aNumberType)
+        return oldIdentifiers;
+    return {
+        a: oldIdentifiers.a.toTree().toIdentifiers(),
+        b: oldIdentifiers.b.toTree().toIdentifiers(),
+        isXRight: false,
+        aNumberType: "Entier",
+    };
+};
+const getInstruction = (identifiers) => {
+    return `Résoudre : 
+  
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b, isXRight, aNumberType } = identifiers;
+    const aTree = reifyAlgebraic(a);
+    const bTree = reifyAlgebraic(b);
+    const solution = frac(bTree, aTree).simplify();
+    const answer = new EqualNode(new VariableNode("x"), solution).toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { a, b, isXRight, aNumberType } = identifiers;
+    const aTree = reifyAlgebraic(a);
+    const bTree = reifyAlgebraic(b);
+    return `Il faut isoler $x$ à ${isXRight ? "droite" : "gauche"}. Pour cela, effectue l'opération des deux côtés de l'équation qui permet de supprimer la multiplication par $${aTree.toTex()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, isXRight, aNumberType } = identifiers;
+    const aTree = reifyAlgebraic(a);
+    const bTree = reifyAlgebraic(b);
+    const affine = new GeneralAffine(aTree, 0).toTree();
+    const equalTree = new EqualNode(affine, bTree);
+    const tree = isXRight ? equalTree.reverse() : equalTree;
+    const answer = getAnswer(identifiers);
+    return `Pour isoler $x$ à ${isXRight ? "droite" : "gauche"}, on divise les deux côtés de l'équation par $${aTree.toTex()}$ : 
+    
+${alignTex([
+        [
+            `${tree.toTex()}`,
+            "\\iff",
+            isXRight
+                ? equal(frac(bTree, aTree), frac(affine, aTree)).toTex()
+                : equal(frac(affine, aTree), frac(bTree, aTree)).toTex(),
+        ],
+        ["", "\\iff", answer],
+    ])}
+    `;
+};
+const getStatementNode = (identifiers) => {
+    const { a, b, isXRight, aNumberType } = identifiers;
+    const aTree = reifyAlgebraic(a);
+    const bTree = reifyAlgebraic(b);
+    const affine = new GeneralAffine(aTree, 0).toTree();
+    const equalTree = new EqualNode(affine, bTree);
+    const tree = isXRight ? equalTree.reverse() : equalTree;
+    return tree;
+};
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getEquationType2ExerciseQuestion = (opts) => {
+    const types = opts?.aNumberType ?? ["Entier"];
+    const b = randint(-10, 11).toTree();
+    const type = random(types);
+    const a = type === "Entier"
+        ? randint(-9, 10, [0, 1]).toTree()
+        : RationalConstructor.randomIrreductibleWithSign().toTree();
+    const isXRight = coinFlip();
+    const identifiers = {
+        a: a.toIdentifiers(),
+        b: b.toIdentifiers(),
+        isXRight,
+        aNumberType: type,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: equationKeys,
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b }) => {
+    const aNode = NodeConstructor.fromIdentifiers(a);
+    const bNode = NodeConstructor.fromIdentifiers(b);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, substract(bNode, aNode).simplify().toTex());
+    while (propositions.length < n) {
+        const bEv = randint(-7, 8, [0, -bNode.evaluate()]);
+        const a = add(aNode, randint(-7, 8, [-aNode.evaluate(), 0]));
+        const wrongAnswer = frac(bEv, a).simplify();
+        tryToAddWrongProp(propositions, new EqualNode(new VariableNode("x"), wrongAnswer).toTex());
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { a, b }) => {
+    const aNode = NodeConstructor.fromIdentifiers(a);
+    const bNode = NodeConstructor.fromIdentifiers(b);
+    const solution = frac(bNode, aNode).simplify().toTex();
+    return equationVEA(ans, solution);
+};
+const options = [
+    {
+        id: "aNumberType",
+        label: "Type du coefficient $a$",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: ["Entier"],
+        values: ["Entier", "Rationnel"],
+    },
+];
+export const equationType2Exercise = {
+    id: "equa2",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $ax=b$",
+    levels: ["4ème", "3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
+    sections: ["Équations"],
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getEquationType2ExerciseQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    options,
+    getCorrection,
+    getHint,
+    getInstruction,
+    getAnswer,
+    getStartStatement,
+    rebuildIdentifiers,
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+/**
+ *  type ax+b=c
+ */
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+};
+export declare const equationType3Exercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=equa3.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"equa3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equa3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAsBvD,CAAC"}

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

@@ -0,0 +1,113 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { equationKeys } from "../../../../exercises/utils/keys/equationKeys.js";
+import { Rational } from "../../../../math/numbers/rationals/rational.js";
+import { Affine } from "../../../../math/polynomials/affine.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { equationVEA } from "../../../../exercises/vea/equationVEA.js";
+const getStatementNode = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const affine = new Affine(a, b).toTree();
+    const statementTree = new EqualNode(affine, new NumberNode(c));
+    return statementTree;
+};
+const getInstruction = (identifiers) => {
+    return `Résoudre : 
+  
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    return "Isolez le terme $x$ dans la partie gauche de l'équation.";
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const statementTex = getStatementNode(identifiers).toTex();
+    const answer = getAnswer(identifiers);
+    return `Commencer par soustraire $${b}$ des deux côtés de l'équation pour 
+    l'éliminer du côté gauche. Ensuite, diviser les deux côtés de l'équation par 
+    $${a}$ pour isoler $x$, ce qui donne : 
+    
+${alignTex([
+        [
+            statementTex,
+            "\\iff",
+            new EqualNode(new MultiplyNode(a.toTree(), new VariableNode("x")), (c - b).toTree()).toTex(),
+        ],
+        ["", "\\iff", answer],
+    ])}`;
+};
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const solution = new Rational(c - b, a).simplify();
+    const answerTree = new EqualNode(new VariableNode("x"), solution.toTree());
+    const answer = answerTree.toTex();
+    return answer;
+};
+const getEquationType3ExerciseQuestion = () => {
+    const b = randint(-10, 11, [0]);
+    const a = randint(-10, 11, [0, 1]);
+    const c = randint(-10, 11);
+    const identifiers = { a, b, c };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
+        keys: equationKeys,
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const wrongAnswer = new Rational(c - b + randint(-7, 8, [0, -c + b]), a + randint(-7, 8, [-a, 0])).simplify();
+        tryToAddWrongProp(propositions, new EqualNode(new VariableNode("x"), wrongAnswer.toTree()).toTex());
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer, a, b, c }) => {
+    const solution = frac(c - b, a)
+        .simplify()
+        .toTex();
+    return equationVEA(ans, solution);
+};
+export const equationType3Exercise = {
+    id: "equa3",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $ax+b=c$",
+    levels: ["4ème", "3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
+    sections: ["Équations"],
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getEquationType3ExerciseQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getAnswer,
+    getInstruction,
+    getCorrection,
+    getHint,
+    getStartStatement,
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+/**
+ *  type ax+b=cx+d
+ */
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+};
+export declare const equationType4Exercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=equa4.d.ts.map