math-exercises 2.2.67 → 2.2.69

package/lib/exercises/math/calcul/fractions/fractionsOperations.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor";
+type Identifiers = {
+    statementIdentifiers: NodeIdentifiers;
+};
+export declare const fractionsOperations: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=fractionsOperations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fractionsOperations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAS1C,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,eAAe,CAAC;CACvC,CAAC;AA6EF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAgBrD,CAAC"}

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fractionsOperations = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rationalVEA_1 = require("../../../../exercises/vea/rationalVEA");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../../math/utils/random/randint");
+const nodeConstructor_1 = require("../../../../tree/nodes/nodeConstructor");
+const addNode_1 = require("../../../../tree/nodes/operators/addNode");
+const divideNode_1 = require("../../../../tree/nodes/operators/divideNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const substractNode_1 = require("../../../../tree/nodes/operators/substractNode");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, rational_1.RationalConstructor.randomIrreductible(100).toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const statement = nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.statementIdentifiers);
+    return statement.simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const statement = nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.statementIdentifiers);
+    return `Calculer : 
+  
+$$
+${statement.toTex({ forceTimesSign: true })}
+$$`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return (0, rationalVEA_1.rationalVEA)(ans, answer);
+};
+const getFractionsOperationsQuestion = (ops) => {
+    const operations = [addNode_1.add, substractNode_1.substract, multiplyNode_1.multiply, divideNode_1.divide];
+    const firstOpIndex = (0, randint_1.randint)(0, operations.length);
+    const secondOpIndex = (0, randint_1.randint)(0, operations.length, [firstOpIndex]);
+    const firstOp = operations[firstOpIndex];
+    const secondOp = operations[secondOpIndex];
+    const rationals = [
+        rational_1.RationalConstructor.randomIrreductible().toTree(),
+        rational_1.RationalConstructor.randomIrreductible().toTree(),
+        rational_1.RationalConstructor.randomIrreductible().toTree(),
+    ];
+    const statement = firstOp(secondOp(rationals[0], rationals[1]), rationals[2]);
+    statement.shuffle();
+    const ids = statement.toIdentifiers();
+    const identifiers = {
+        statementIdentifiers: ids,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.fractionsOperations = {
+    id: "fractionsOperations",
+    connector: "=",
+    label: "Calculs avec des fractions : mélange d'opérations",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getFractionsOperationsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    // getHint,
+    // getCorrection,
+    getAnswer,
+};

package/lib/exercises/math/calcul/fractions/index.d.ts

@@ -10,4 +10,5 @@ export * from "./periodicWritingToFraction";
 export * from "./fractionsSumsSameDenominators";
 export * from "./fractionsSumsMultiplesDenominators";
 export * from "./fractionsSumsPrimeDenominators";
+export * from "./fractionsOperations";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,sCAAsC,CAAC;AACrD,cAAc,kCAAkC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,sCAAsC,CAAC;AACrD,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC"}

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

@@ -26,3 +26,4 @@ __exportStar(require("./periodicWritingToFraction"), exports);
 __exportStar(require("./fractionsSumsSameDenominators"), exports);
 __exportStar(require("./fractionsSumsMultiplesDenominators"), exports);
 __exportStar(require("./fractionsSumsPrimeDenominators"), exports);
+__exportStar(require("./fractionsOperations"), exports);

package/lib/exercises/math/derivation/derivative/rootFunctionDerivative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rootFunctionDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/rootFunctionDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"rootFunctionDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/rootFunctionDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAiBlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2EF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

package/lib/exercises/math/derivation/derivative/rootFunctionDerivative.js

@@ -11,6 +11,16 @@ const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
 const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
 const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
+const getStatementNode = (identifiers) => {
+    return (0, multiplyNode_1.multiply)(identifiers.a, (0, sqrtNode_1.sqrt)("x"));
+};
+const getInstruction = (identifiers) => {
+    return `Déterminer la fonction dérivée $f'$ de la fonction $f$ définie par :
+  
+$$
+f(x) = ${getStatementNode(identifiers).toTex()}
+$$ `;
+};
 const getRootFunctionDerivative = () => {
     const a = (0, randint_1.randint)(-19, 20, [0]);
     let instruction = `Déterminer la fonction dérivée $f'$ de la fonction $f$ définie par $f(x) =$ `;
@@ -65,7 +75,7 @@ const isAnswerValid = (ans, { a }) => {
 exports.rootFunctionDerivative = {
     id: "rootFunctionDerivative",
     connector: "=",
-    label: "Dérivée d'une fonction racine",
+    label: "Dérivée d'une fonction racine carrée",
     levels: ["1reESM", "1reSpé", "1reTech", "MathComp"],
     sections: ["Dérivation", "Racines carrées"],
     isSingleStep: false,

package/lib/exercises/math/functions/absolute/absolueValueAffineEquation.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { GeneralAffineIdentifiers } from "../../../../math/polynomials/generalAffine";
+type Identifiers = {
+    firstAffine: GeneralAffineIdentifiers;
+    secondAffine: GeneralAffineIdentifiers;
+};
+export declare const absolueValueAffineEquation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=absolueValueAffineEquation.d.ts.map

package/lib/exercises/math/functions/absolute/absolueValueAffineEquation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"absolueValueAffineEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/absolute/absolueValueAffineEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EAGL,wBAAwB,EACzB,MAAM,sCAAsC,CAAC;AAM9C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,wBAAwB,CAAC;IACtC,YAAY,EAAE,wBAAwB,CAAC;CACxC,CAAC;AA4KF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAiB5D,CAAC"}

package/lib/exercises/math/functions/absolute/absolueValueAffineEquation.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.absolueValueAffineEquation = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const integer_1 = require("../../../../math/numbers/integer/integer");
+const nombre_1 = require("../../../../math/numbers/nombre");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const generalAffine_1 = require("../../../../math/polynomials/generalAffine");
+const equalNode_1 = require("../../../../tree/nodes/equations/equalNode");
+const absNode_1 = require("../../../../tree/nodes/functions/absNode");
+const rationalParser_1 = require("../../../../tree/parsers/rationalParser");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const fracs = [
+            rational_1.RationalConstructor.randomIrreductibleWithSign().toTree(),
+            rational_1.RationalConstructor.randomIrreductibleWithSign().toTree(),
+        ].sort((a, b) => a.evaluate() - b.evaluate());
+        (0, exercise_1.tryToAddWrongProp)(propositions, `x=${fracs[0].toTex()}\\text{ ou }${fracs[1].toTex()}`);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const affines = [
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.firstAffine),
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.secondAffine),
+    ];
+    const firstIntersec = affines[0].xIntersect(affines[1]);
+    const oppositeAffine = affines[1].opposite();
+    const secondIntersec = oppositeAffine.xIntersect(affines[0]);
+    const res = [firstIntersec, secondIntersec]
+        .filter(Boolean)
+        .sort((a, b) => a.evaluate() - b.evaluate());
+    return res;
+};
+const getAnswer = (identifiers) => {
+    const nodes = getAnswerNode(identifiers);
+    if (nodes.length > 1)
+        return `x=${nodes[0].toTex()}\\text{ ou }x=${nodes[1].toTex()}`;
+    return `x=${nodes[0]?.toTex() || nodes[1]?.toTex()}`;
+};
+const getInstruction = (identifiers) => {
+    const affines = [
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.firstAffine),
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.secondAffine),
+    ];
+    const node = (0, equalNode_1.equal)((0, absNode_1.abs)(affines[0].toTree()), (0, absNode_1.abs)(affines[1].toTree()));
+    return `Résoudre : 
+  
+$$
+${node.toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    return `L'égalité $|a|=|b|$ est vraie si et seulement si $a = b$ ou $a = -b$.`;
+};
+const getCorrection = (identifiers) => {
+    const affines = [
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.firstAffine),
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.secondAffine),
+    ];
+    const firstIntersec = affines[0].xIntersect(affines[1]);
+    const oppositeAffine = affines[1].opposite();
+    const secondIntersec = oppositeAffine.xIntersect(affines[0]);
+    const res = [firstIntersec, secondIntersec]
+        .filter(Boolean)
+        .sort((a, b) => a.evaluate() - b.evaluate());
+    return `L'égalité $|a|=|b|$ est vraie si et seulement si $a = b$ ou $a=-b$.
+  
+On doit donc résoudre deux équations: d'une part,
+
+$$
+${affines[0].toTree().toTex()} = ${affines[1].toTree().toTex()}
+$$
+
+${firstIntersec
+        ? `ce qui donne : 
+  
+  $$
+  x=${firstIntersec?.toTex()}
+  $$`
+        : "qui n'a pas de solution, "}
+
+et d'autre part :
+
+$$
+${affines[0].toTree().toTex()} = ${oppositeAffine.toTree().toTex()}
+$$
+
+${secondIntersec
+        ? `ce qui donne : 
+  
+$$
+x=${secondIntersec?.toTex()}
+$$`
+        : "qui n'a pas de solution."}
+
+
+Ainsi, la solution de cette équation est :
+
+$$
+${res.length > 1
+        ? `x=${res[0].toTex()} \\text{ ou } x=${res[1].toTex()}`
+        : `x=${res[0]?.toTex() || res[1]?.toTex()}`}
+`;
+};
+const getKeys = (identifiers) => {
+    return ["x", "equal", "ou"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const parsedOu = ans.split("\\text{ ou }");
+    console.log(parsedOu);
+    try {
+        const nodes = [];
+        parsedOu.forEach((item) => {
+            let formated = item
+                .replaceAll("\\text{", "")
+                .replaceAll("}", "")
+                .replaceAll(" ", "");
+            const equalForm = formated.split("=");
+            if (equalForm.length > 1 && equalForm[0] !== "x")
+                throw Error("wrong answer");
+            const nbStr = equalForm.length > 1 ? equalForm[1] : formated;
+            const node = (0, rationalParser_1.rationalParser)(nbStr);
+            if (!node)
+                throw Error("wrong answer");
+            nodes.push(node);
+        });
+        const answerNodes = getAnswerNode(identifiers);
+        return answerNodes.every((e) => nodes.some((n) => n.evaluate() === e.evaluate()));
+    }
+    catch (err) {
+        return false;
+    }
+};
+const getAbsolueValueAffineEquationQuestion = (ops) => {
+    const types = [nombre_1.NumberType.Integer];
+    const [a, c] = nombre_1.NombreConstructor.manyRandom(4, {
+        types,
+        excludes: [new integer_1.Integer(0)],
+    }).map((e) => e.toTree());
+    const [b, d] = nombre_1.NombreConstructor.manyRandom(4, {
+        types,
+    }).map((e) => e.toTree());
+    const identifiers = {
+        firstAffine: new generalAffine_1.GeneralAffine(a, b).toIdentifiers(),
+        secondAffine: new generalAffine_1.GeneralAffine(c, d).toIdentifiers(),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.absolueValueAffineEquation = {
+    id: "absolueValueAffineEquation",
+    connector: "\\iff",
+    label: "Résoudre une équation avec valeur absolue du type $|ax+b|=|cx+d|$",
+    isSingleStep: false,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getAbsolueValueAffineEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/absolute/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./absoluteValueEquations";
 export * from "./absoluteValueInequations";
+export * from "./absolueValueAffineEquation";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/absolute/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/absolute/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/absolute/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC"}

package/lib/exercises/math/functions/absolute/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./absoluteValueEquations"), exports);
 __exportStar(require("./absoluteValueInequations"), exports);
+__exportStar(require("./absolueValueAffineEquation"), exports);

package/lib/exercises/math/functions/affines/leadingCoefficient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"leadingCoefficient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/leadingCoefficient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAuEF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}
+{"version":3,"file":"leadingCoefficient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/leadingCoefficient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAgEF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}

package/lib/exercises/math/functions/affines/leadingCoefficient.js

@@ -3,36 +3,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.leadingCoefficient = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rationalVEA_1 = require("../../../../exercises/vea/rationalVEA");
 const colors_1 = require("../../../../geogebra/colors");
 const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
-const integer_1 = require("../../../../math/numbers/integer/integer");
 const rational_1 = require("../../../../math/numbers/rationals/rational");
 const randint_1 = require("../../../../math/utils/random/randint");
 const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
 const getLeadingCoefficientQuestion = () => {
     let xA, yA, xB, yB;
     [xA, yA] = [1, 2].map((el) => (0, randint_1.randint)(-5, 6));
     xB = xA > 0 ? (0, randint_1.randint)(xA - 4, 6, [xA]) : (0, randint_1.randint)(-4, xA + 5, [xA]); // l'écart entre les deux points ne soit pas grand
     yB = yA > 0 ? (0, randint_1.randint)(yA - 4, 6) : (0, randint_1.randint)(-4, yA + 5);
-    const a = new rational_1.Rational(yB - yA, xB - xA).simplify();
-    const b = a.opposite().multiply(new integer_1.Integer(xA)).add(new integer_1.Integer(yA));
-    const aTree = a.toTree();
-    const bTree = b.toTree();
-    const aString = aTree.toMathString();
-    const bString = bTree.toMathString();
+    const a = (0, fractionNode_1.frac)(yB - yA, xB - xA).simplify();
+    const answer = a.toTex();
     const xMin = Math.min(xA, xB);
     const xMax = Math.max(xA, xB);
     const yMin = Math.min(yA, yB);
     const yMax = Math.max(yA, yB);
     const commands = [
-        `f(x) = (${aString}) * x + (${bString})`,
-        `SetColor(f, "${(0, colors_1.randomColor)()}")`,
+        `L = Line((${xA}, ${yA}), (${xB}, ${yB}))`,
+        "SetFixed(L, true)",
+        `SetColor(L, "${(0, colors_1.randomColor)()}")`,
     ];
     const ggb = new geogebraConstructor_1.GeogebraConstructor({
         commands,
     });
-    const answer = aTree.toTex();
     const question = {
         instruction: "Déterminer le coefficient directeur de la droite représentée ci-dessous : ",
         answer,
@@ -56,12 +53,8 @@ const getPropositions = (n, { answer, xA, xB, yA, yB }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { xA, xB, yA, yB }) => {
-    const leadingCoeff = new rational_1.Rational(yB - yA, xB - xA)
-        .simplify()
-        .toTree({ allowFractionToDecimal: true });
-    const texs = leadingCoeff.toAllValidTexs();
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer, xA, xB, yA, yB }) => {
+    return (0, rationalVEA_1.rationalVEA)(ans, answer);
 };
 exports.leadingCoefficient = {
     id: "leadingCoefficient",

package/lib/exercises/math/functions/trinoms/rootsProduct.js

@@ -77,7 +77,7 @@ const getRootsProductQuestion = (ops) => {
     //ac <= 0
     const a = (0, randint_1.randint)(-10, 10, [0]);
     const b = (0, randint_1.randint)(-10, 10);
-    const c = (a / Math.abs(a)) * (0, randint_1.randint)(-10, 10, !b ? [0] : []);
+    const c = (a / Math.abs(a)) * (0, randint_1.randint)(-10, 0, !b ? [0] : []);
     const trinom = new generalTrinom_1.GeneralTrinom(a, b, c);
     const identifiers = {
         trinomIdentifiers: trinom.toIdentifiers(),

package/lib/exercises/math/functions/trinoms/rootsSum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rootsSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/rootsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAGL,wBAAwB,EACzB,MAAM,sCAAsC,CAAC;AAO9C,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,wBAAwB,CAAC;CAC7C,CAAC;AAqGF,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAiB1C,CAAC"}
+{"version":3,"file":"rootsSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/rootsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAGL,wBAAwB,EACzB,MAAM,sCAAsC,CAAC;AAO9C,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,wBAAwB,CAAC;CAC7C,CAAC;AAoGF,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAiB1C,CAAC"}

package/lib/exercises/math/functions/trinoms/rootsSum.js

@@ -56,7 +56,7 @@ const getCorrection = (identifiers) => {
     return `Si $f(x) = ax^2 + bx + c$ admet deux racines, alors leur somme $S$ vaut : 
   
 $$
-S = \\frac{c}{a}
+S = \\frac{-b}{a}
 $$
 
 Ici, on a $a = ${aTex}$ et $b = ${bTex}$, donc :
@@ -73,11 +73,10 @@ const isAnswerValid = (ans, { answer }) => {
     return (0, rationalVEA_1.rationalVEA)(ans, answer);
 };
 const getRootsSumQuestion = (ops) => {
-    //(b,c) != 0
     //ac <= 0
     const a = (0, randint_1.randint)(-10, 10, [0]);
     const b = (0, randint_1.randint)(-10, 10);
-    const c = (a / Math.abs(a)) * (0, randint_1.randint)(-10, 10, !b ? [0] : []);
+    const c = (a / Math.abs(a)) * (0, randint_1.randint)(-10, 0, !b ? [0] : []);
     // const trinom = GeneralTrinomConstructor.randomNiceRoots(2);
     const trinom = new generalTrinom_1.GeneralTrinom(a, b, c);
     const identifiers = {

package/lib/exercises/math/geometry/cartesian/placeAbscissOnLine.js

@@ -55,7 +55,7 @@ const isGGBAnswerValid = (ans, { ggbAnswer, absciss, abscissTex, abscissType, ax
     const points = (0, parseGGBPoints_1.parseGGBPoints)(ans).map((p) => (0, ggbPointToCoords_1.ggbPointToCoords)(p));
     return (points.length === 1 &&
         points[0].y === 0 &&
-        Math.abs(points[0].x - coeff) < 0.1);
+        Math.abs(points[0].x - coeff) < 0.2);
 };
 const getPlaceAbscissOnLineQuestion = () => {
     const abscissType = (0, random_1.random)([

package/lib/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pointImageFromTranslation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAGL,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAMnC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAiIF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAepE,CAAC"}
+{"version":3,"file":"pointImageFromTranslation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAGL,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAMnC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAmIF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAepE,CAAC"}

package/lib/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.js

@@ -57,7 +57,10 @@ const isGGBAnswerValid = (ans, { ggbAnswer }) => {
     const studentAns = ans.filter((c) => !["A", "B", "C", "D"].includes(c[0]));
     if (studentAns.length !== 1)
         return false;
-    const coords = (0, ggbPointToCoords_1.ggbPointToCoords)(studentAns[0].split("=")[1]);
+    const studentPoint = studentAns[0].split("=")[1];
+    if (studentPoint === undefined)
+        return false;
+    const coords = (0, ggbPointToCoords_1.ggbPointToCoords)(studentPoint);
     const coordsAns = (0, ggbPointToCoords_1.ggbPointToCoords)(ggbAnswer[0].split("=")[1]);
     return ((0, approxEqual_1.approxEqual)(coords.x, coordsAns.x, 0.2) &&
         (0, approxEqual_1.approxEqual)(coords.y, coordsAns.y, 0.2));

package/lib/index.d.ts

@@ -78,6 +78,8 @@ declare const mathExercises: (Exercise<{
     num2: number;
     denom1: number;
     denom2: number;
+}, {}> | Exercise<{
+    statementIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
 }, {}> | Exercise<{
     numbers: number[];
 }, {}> | Exercise<{
@@ -576,6 +578,9 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     isStrict: boolean;
+}, {}> | Exercise<{
+    firstAffine: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers;
+    secondAffine: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers;
 }, {}> | Exercise<{
     xA: number;
     yA: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/math/numbers/nombre.d.ts

@@ -18,5 +18,10 @@ export declare abstract class NombreConstructor {
         types?: NumberType[];
         excludes?: Nombre[];
     }): Nombre;
+    static manyRandom(n: number, { types, excludes, allDifferent, }?: {
+        types?: NumberType[];
+        excludes?: Nombre[];
+        allDifferent?: boolean;
+    }): Nombre[];
 }
 //# sourceMappingURL=nombre.d.ts.map

package/lib/math/numbers/nombre.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nombre.d.ts","sourceRoot":"","sources":["../../../src/math/numbers/nombre.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAQ1D,oBAAY,UAAU;IACpB,OAAO,IAAA;IACP,OAAO,IAAA;IACP,QAAQ,IAAA;IACR,IAAI,IAAA;CACL;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,CAAC;IAC9C,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;CAChC;AAED,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM,CAAC,EACZ,KAAK,EACL,QAAQ,GACT,GAAE;QACD,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KAChB;CAiCP"}
+{"version":3,"file":"nombre.d.ts","sourceRoot":"","sources":["../../../src/math/numbers/nombre.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAQ1D,oBAAY,UAAU;IACpB,OAAO,IAAA;IACP,OAAO,IAAA;IACP,QAAQ,IAAA;IACR,IAAI,IAAA;CACL;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,CAAC;IAC9C,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;CAChC;AAED,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM,CAAC,EACZ,KAAK,EACL,QAAQ,GACT,GAAE;QACD,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KAChB;IAiCN,MAAM,CAAC,UAAU,CACf,CAAC,EAAE,MAAM,EACT,EACE,KAAK,EACL,QAAQ,EACR,YAAoB,GACrB,GAAE;QACD,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,YAAY,CAAC,EAAE,OAAO,CAAC;KACnB;CAaT"}

package/lib/math/numbers/nombre.js

@@ -48,5 +48,17 @@ class NombreConstructor {
         }
         return res;
     }
+    static manyRandom(n, { types, excludes, allDifferent = false, } = {}) {
+        const res = [];
+        res.push(NombreConstructor.random({ types, excludes }));
+        for (let i = 0; i < n - 1; i++) {
+            let b;
+            do {
+                b = NombreConstructor.random({ types, excludes });
+            } while (allDifferent && res.some((el) => el.equals(b)));
+            res.push(b);
+        }
+        return res;
+    }
 }
 exports.NombreConstructor = NombreConstructor;

package/lib/math/polynomials/generalAffine.d.ts

@@ -1,10 +1,23 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor";
+export declare abstract class GeneralAffineConstructor {
+    static fromIdentifiers(identifiers: GeneralAffineIdentifiers): GeneralAffine;
+}
+export type GeneralAffineIdentifiers = {
+    id: "affine";
+    a: NodeIdentifiers;
+    b: NodeIdentifiers;
+    variable?: string;
+};
 export declare class GeneralAffine {
     a: AlgebraicNode;
     b: AlgebraicNode;
     variable: string;
     constructor(a: number | AlgebraicNode, b: number | AlgebraicNode, variable?: string);
+    toIdentifiers(): GeneralAffineIdentifiers;
     getRoot(): AlgebraicNode;
     toTree(): import("../../tree/nodes/operators/addNode").AddNode | import("../../tree/nodes/operators/multiplyNode").MultiplyNode;
+    xIntersect(aff: GeneralAffine): AlgebraicNode | undefined;
+    opposite(): GeneralAffine;
 }
 //# sourceMappingURL=generalAffine.d.ts.map

package/lib/math/polynomials/generalAffine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generalAffine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalAffine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAO/D,qBAAa,aAAa;IACxB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;gBAGf,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,QAAQ,GAAE,MAAY;IAWxB,OAAO,IAAI,aAAa;IAIxB,MAAM;CAKP"}
+{"version":3,"file":"generalAffine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalAffine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAEL,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAQ1C,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,wBAAwB;CAM7D;AACD,MAAM,MAAM,wBAAwB,GAAG;IACrC,EAAE,EAAE,QAAQ,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,qBAAa,aAAa;IACxB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;gBAGf,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,QAAQ,GAAE,MAAY;IAUxB,aAAa,IAAI,wBAAwB;IAQzC,OAAO,IAAI,aAAa;IAIxB,MAAM;IAMN,UAAU,CAAC,GAAG,EAAE,aAAa;IAI7B,QAAQ;CAGT"}