math-exercises 3.0.89 → 3.0.90

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

@@ -37,10 +37,10 @@ $$
 ${leftNode.toTex()} ${inequalitySign ? "<" : ">"} ${rightNode.toTex()}
 $$
 
-Cette inéquation est-elle vraie pour $x = ${x}$ ?`;
+Cette inéquation est-elle vraie pour pour $x = ${x}$ ?`;
 };
 const getHint = (identifiers) => {
-    return `Remplace $x$ par $${identifiers.x}$ dans les deux membres. Ensuite, vérifie si l'inégalité est vraie ou non.`;
+    return `Remplacer $x$ par $${identifiers.x}$ dans les deux membres. Ensuite, vérifie si l'inégalité est vraie ou non.`;
 };
 const reverseSign = (sign) => {
     let x = "";

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,EAoBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmHF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}
+{"version":3,"file":"simpleDistriXCoeff.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/simpleDistriXCoeff.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmHF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}

package/lib/exercises/math/conversion/lengthConversion.js

@@ -83,7 +83,7 @@ const getLengthConversion = (opts) => {
     const randomUnitInstructionIndex = random(availableUnitsIndexes, [
         randomUnitIndex,
     ]);
-    const randomLength = doWhile(() => DecimalConstructor.random(0, 1000, randint(0, 4)), (x) => x.value === 0);
+    const randomLength = doWhile(() => DecimalConstructor.random(1, 1000, randint(0, 4)), (x) => x.value === 0);
     const identifiers = {
         randomLength: randomLength.value,
         randomUnitIndex,

package/lib/exercises/math/functions/affines/affineFromExercise.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    phrase: number;
+    initial: number;
+    growth: number;
+};
+export declare const affineFromExercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=affineFromExercise.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"affineFromExercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineFromExercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAuHF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAiBpD,CAAC"}

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

@@ -0,0 +1,111 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { phrase, initial, growth } = identifiers;
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, add(multiply(initial, new VariableNode("x")), growth).toTex());
+    tryToAddWrongProp(propositions, add(multiply(growth, new VariableNode("n")), initial).toTex());
+    tryToAddWrongProp(propositions, add(multiply(initial, growth), new VariableNode("x")).toTex());
+    tryToAddWrongProp(propositions, multiply(add(initial, growth).simplify(), new VariableNode("x")).toTex());
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return add(multiply(identifiers.growth, new VariableNode("x")), identifiers.initial).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { phrase, initial, growth } = identifiers;
+    switch (phrase) {
+        case 0:
+            return `On suppose qu'une plante, d'une hauteur initiale de 
+      $${initial}\\ \\textrm{cm}$, croît chaque jour de $${growth.frenchify()}\\ \\textrm{cm}$. 
+      Quelle est sa hauteur (en $\\textrm{cm}$) après $x$ jours ?`;
+        case 1:
+        default:
+            return `Une compagnie de taxis propose un tarif qui inclut un
+      montant fixe de $${initial}\\ €$ et un montant variable de $${growth.frenchify()}\\ €$
+      par kilomètre parcouru.
+      Quel est le prix payé (en $€$) pour $x \\ \\textrm{km}$ parcourus ?`;
+    }
+};
+const getHint = (identifiers) => {
+    const { growth, initial, phrase } = identifiers;
+    if (phrase === 0) {
+        return `Quel calcul permet de trouver la hauteur de la plante au bout de $10$ jours ?
+    
+Inspire toi de ce calcul pour déterminer la hauteur de la plante au bout de $x$ jours.`;
+    }
+    return `Quel calcul permet de trouver le prix payé pour $10$ kilomètres parcourus ?
+
+Inspire toi de ce calcul pour déterminer le prix payé pour $x$ kilomètres parcourus.
+  `;
+};
+const getCorrection = (identifiers) => {
+    const { growth, initial, phrase } = identifiers;
+    if (phrase === 0) {
+        return `Chaque jour, la plante gagne $${growth.frenchify()}\\ \\textrm{cm}$. Au bout de $x$ jours, la plante a donc gagné $x\\times ${growth.frenchify()}\\ \\textrm{cm}$.
+
+La hauteur initiale de la plante est de $${initial}\\ \\textrm{cm}$.
+
+Au bout de $x$ jours, la plante a donc une hauteur de :
+
+$$
+${getAnswer(identifiers)}\\ \\textrm{cm}
+$$`;
+    }
+    return `Pour chaque kilomètre parcouru, le prix augmente de $${growth.frenchify()}\\ €$. Au bout de $x$ kilomètres, le prix augmente donc de $x\\times ${growth.frenchify()}\\ \\ €$.
+
+Le montant fixe initial du trajet est de $${initial}\\ €$.
+
+Pour $x$ kilomètres parcourus, le prix du trajet est donc de : 
+
+$$
+${getAnswer(identifiers)}\\ €
+$$`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    return parseAlgebraic(ans)
+        .simplify()
+        .equals(parseAlgebraic(answer).simplify());
+};
+const getAffineFromExerciseQuestion = (ops) => {
+    const phrase = randint(0, 2);
+    const initial = randint(2, 20);
+    const growth = randfloat(0, 4, 2, [0]);
+    const identifiers = { phrase, initial, growth };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const affineFromExercise = {
+    id: "affineFromExercise",
+    label: "Écrire la fonction affine correspondant à une situation donnée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAffineFromExerciseQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -11,4 +11,5 @@ export * from "./affineAdjustmentRsquared.js";
 export * from "./affineAdjustmentComplete.js";
 export * from "./affineMeanValue.js";
 export * from "./affineExpressionFromTwoImages.js";
+export * from "./affineFromExercise.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oCAAoC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oCAAoC,CAAC;AACnD,cAAc,yBAAyB,CAAC"}

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

@@ -11,3 +11,4 @@ export * from "./affineAdjustmentRsquared.js";
 export * from "./affineAdjustmentComplete.js";
 export * from "./affineMeanValue.js";
 export * from "./affineExpressionFromTwoImages.js";
+export * from "./affineFromExercise.js";

package/lib/exercises/math/functions/parity/finishParityFunctionGraph.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    isEven: boolean;
+    isLeftSideGiven: boolean;
+    givenPointsCoords: number[][];
+};
+export declare const finishParityFunctionGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=finishParityFunctionGraph.d.ts.map

package/lib/exercises/math/functions/parity/finishParityFunctionGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finishParityFunctionGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/parity/finishParityFunctionGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,eAAe,EAAE,OAAO,CAAC;IACzB,iBAAiB,EAAE,MAAM,EAAE,EAAE,CAAC;CAC/B,CAAC;AAoLF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAkB3D,CAAC"}

package/lib/exercises/math/functions/parity/finishParityFunctionGraph.js

@@ -0,0 +1,154 @@
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+const getInstruction = (identifiers) => {
+    const { isEven, givenPointsCoords, isLeftSideGiven } = identifiers;
+    let xMin = (isLeftSideGiven ? Math.min : Math.max)(...givenPointsCoords.map((n) => n[0]));
+    let xMax = -xMin;
+    if (xMin > xMax)
+        [xMin, xMax] = [xMax, xMin];
+    return `On considère la fonction $f$ définie sur $[${xMin}; ${xMax}]$ et dont la courbe représentative est donnée ci-dessous. 
+    
+La fonction $f$ est ${isEven ? "paire" : "impaire"}.
+
+Compléter la courbe représentative de $f$.`;
+};
+const getHint = (identifiers) => {
+    return `Une fonction est paire si sa courbe représentative est symétrique par rapport à l'axe des ordonnées.
+  
+Une fonction est impaire si sa courbe représentative est symétrique par rapport à l'origine du repère.`;
+};
+const getCorrection = (identifiers) => {
+    const { isEven, givenPointsCoords, isLeftSideGiven } = identifiers;
+    if (isEven) {
+        return `Puisque $f$ est paire, alors sa courbe représentative est symétrique par rapport à l'axe des ordonnées. 
+    
+On trace donc les symétriques de chacun des segments composant la courbe de $f$ par rapport à l'axe des ordonnées.`;
+    }
+    return `Puisque $f$ est impaire, alors sa courbe représentative est symétrique par rapport à l'origine du repère.
+  
+On trace donc les symétriques de chacun des segments composant la courbe de $f$ par rapport à l'origine du repère.`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { isEven, givenPointsCoords, isLeftSideGiven } = identifiers;
+    const symPointsCoords = [];
+    if (isEven) {
+        for (const coords of [...givenPointsCoords].reverse()) {
+            symPointsCoords.push([-coords[0], coords[1]]);
+        }
+    }
+    else {
+        for (const coords of [...givenPointsCoords].reverse()) {
+            symPointsCoords.push([-coords[0], -coords[1]]);
+        }
+    }
+    const commands = [];
+    for (let i = 1; i < symPointsCoords.length; i++) {
+        commands.push(`Segment((${symPointsCoords[i - 1][0]}, ${symPointsCoords[i - 1][1]}), (${symPointsCoords[i][0]}, ${symPointsCoords[i][1]}))`);
+    }
+    return commands;
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { isEven, givenPointsCoords, isLeftSideGiven } = identifiers;
+    const commands = [];
+    for (let i = 1; i < givenPointsCoords.length; i++) {
+        commands.push(`Segment((${givenPointsCoords[i - 1][0]}, ${givenPointsCoords[i - 1][1]}), (${givenPointsCoords[i][0]}, ${givenPointsCoords[i][1]}))`);
+    }
+    const ggb = new GeogebraConstructor({
+        commands,
+        customToolBar: toolBarConstructor({
+            segment: true,
+        }),
+    });
+    let xMax = Math.abs((isLeftSideGiven ? Math.min : Math.max)(...givenPointsCoords.map((n) => n[0])));
+    const yMin = Math.min(...givenPointsCoords.map((n) => n[1]));
+    const yMax = Math.max(...givenPointsCoords.map((n) => n[1]));
+    const coords = isEven
+        ? [-xMax - 2, xMax + 2, yMin - 2, yMax + 2]
+        : [
+            -xMax - 2,
+            xMax + 2,
+            Math.min(...givenPointsCoords.map((n) => -n[1])) - 2,
+            Math.max(...givenPointsCoords.map((n) => -n[1])) + 2,
+        ];
+    return ggb.getOptions({
+        coords,
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, givenPointsCoords, isEven }) => {
+    const points = parseGGBPoints(ans).map((p) => ggbPointToCoords(p));
+    if (isEven) {
+        return (points.length === givenPointsCoords.length &&
+            points.every((p) => givenPointsCoords.some((c) => Math.abs(p.x + c[0]) < 0.5 && Math.abs(p.y - c[1]) < 0.5)));
+    }
+    else {
+        return (points.length === givenPointsCoords.length &&
+            points.every((p) => givenPointsCoords.some((c) => Math.abs(p.x + c[0]) < 0.5 && Math.abs(p.y + c[1]) < 0.5)));
+    }
+};
+const getFinishParityFunctionGraphQuestion = () => {
+    const isEven = coinFlip();
+    const isLeftSideGiven = coinFlip();
+    const givenPointsCoords = [];
+    if (isLeftSideGiven) {
+        const point0 = [randint(-7, -4), randint(-5, 5, [0])];
+        givenPointsCoords.push(point0);
+        const pointOrigin = isEven ? [0, randint(-3, 3)] : [0, 0];
+        givenPointsCoords.push([
+            randint(point0[0] + 1, 0),
+            doWhile(() => randint(-5, 5), (x) => (x <= point0[1] && x >= pointOrigin[1]) ||
+                (x >= point0[1] && x <= pointOrigin[1])),
+        ]);
+        givenPointsCoords.push(pointOrigin);
+    }
+    else {
+        const pointOrigin = isEven ? [0, randint(-3, 3)] : [0, 0];
+        givenPointsCoords.push(pointOrigin);
+        const point3 = [randint(4, 7), randint(-5, 5)];
+        const point2 = [
+            randint(1, 4),
+            doWhile(() => randint(-5, 5), (x) => (x <= point3[1] && x >= pointOrigin[1]) ||
+                (x >= point3[1] && x <= pointOrigin[1])),
+        ];
+        givenPointsCoords.push(point2);
+        givenPointsCoords.push(point3);
+    }
+    const identifiers = {
+        isEven,
+        isLeftSideGiven,
+        givenPointsCoords,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const finishParityFunctionGraph = {
+    id: "finishParityFunctionGraph",
+    label: "Compléter la représentation graphique d'une fonction paire ou impaire",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFinishParityFunctionGraphQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -1,3 +1,4 @@
 export * from "./parityFromAlgebra.js";
 export * from "./parityFromGraph.js";
+export * from "./finishParityFunctionGraph.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/parity/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/parity/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC"}

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

@@ -1,2 +1,3 @@
 export * from "./parityFromAlgebra.js";
 export * from "./parityFromGraph.js";
+export * from "./finishParityFunctionGraph.js";

package/lib/exercises/math/functions/sign/affineProductSignTable.d.ts

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

package/lib/exercises/math/functions/sign/affineProductSignTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affineProductSignTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/affineProductSignTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;CACvB,CAAC;AAmNF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}

package/lib/exercises/math/functions/sign/affineProductSignTable.js

@@ -0,0 +1,201 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { firstDegreeInequationResolutionTex } from "../../../../tree/nodes/inequations/inequationNode.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getAnswerTable = (identifiers) => {
+    const affine1 = AffineConstructor.fromCoeffs(identifiers.affine1Coeffs);
+    const affine2 = AffineConstructor.fromCoeffs(identifiers.affine2Coeffs);
+    let root1 = affine1.getRoot().toTree();
+    let root2 = affine2.getRoot().toTree();
+    const isRoot1OfAffine1 = root1.evaluate() < root2.evaluate();
+    if (!isRoot1OfAffine1) {
+        [root1, root2] = [root2, root1];
+    }
+    const signs1 = affine1.a > 0 ? ["-", "+"] : ["+", "-"];
+    const signs2 = affine2.a > 0 ? ["-", "+"] : ["+", "-"];
+    const signs3 = affine1.a * affine2.a > 0 ? ["+", "-", "+"] : ["-", "+", "-"];
+    return [
+        [
+            "$x$",
+            "-\\infty",
+            "\\ ",
+            root1.toTex(),
+            "\\ ",
+            root2.toTex(),
+            "\\ ",
+            "+\\infty",
+        ],
+        [
+            `$${affine1.toTree().toTex()}$`,
+            "\\ ",
+            signs1[0],
+            isRoot1OfAffine1 ? "0" : signs1[0],
+            isRoot1OfAffine1 ? signs1[1] : signs1[0],
+            isRoot1OfAffine1 ? signs1[1] : "0",
+            signs1[1],
+            "\\ ",
+        ],
+        [
+            `$${affine2.toTree().toTex()}$`,
+            "\\ ",
+            signs2[0],
+            !isRoot1OfAffine1 ? "0" : signs2[0],
+            !isRoot1OfAffine1 ? signs2[1] : signs2[0],
+            !isRoot1OfAffine1 ? signs2[1] : "0",
+            signs2[1],
+            "\\ ",
+        ],
+        [`$f(x)$`, "\\ ", signs3[0], "0", signs3[1], "0", signs3[2], "\\ "],
+    ];
+};
+const getInstruction = (identifiers) => {
+    const affine1 = AffineConstructor.fromCoeffs(identifiers.affine1Coeffs);
+    const affine2 = AffineConstructor.fromCoeffs(identifiers.affine2Coeffs);
+    const product = multiply(affine1.toTree(), affine2.toTree());
+    return `Compléter le tableau de signes suivant afin de déterminer le signe de la fonction $f$ définie par : 
+  
+$$
+f(x) = ${product.toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    const affine1 = AffineConstructor.fromCoeffs(identifiers.affine1Coeffs);
+    const affine2 = AffineConstructor.fromCoeffs(identifiers.affine2Coeffs);
+    return `Résout les inéquations $${affine1.toTree().toTex()}>0$ et $${affine2
+        .toTree()
+        .toTex()}>0$.
+  
+Puis, utilise la règle des signes pour déterminer le signe de $f(x)$.`;
+};
+const getCorrection = (identifiers) => {
+    const affine1 = AffineConstructor.fromCoeffs(identifiers.affine1Coeffs);
+    const affine2 = AffineConstructor.fromCoeffs(identifiers.affine2Coeffs);
+    let root1 = affine1.getRoot().toTree();
+    let root2 = affine2.getRoot().toTree();
+    const isRoot1OfAffine1 = root1.evaluate() < root2.evaluate();
+    if (!isRoot1OfAffine1) {
+        [root1, root2] = [root2, root1];
+    }
+    const signs3 = affine1.a * affine2.a > 0
+        ? ["positif", "négatif", "positif"]
+        : ["négatif", "positif", "négatif"];
+    return `On résout l'inéquation $${affine1.toTree().toTex()} > 0$ :
+
+$$
+${firstDegreeInequationResolutionTex(affine1, ">", new NumberNode(0))}
+$$
+
+On en déduit que $${affine1.toTree().toTex()}$ est ${affine1.a > 0 ? "négatif" : "positif"} sur $]-\\infty; ${(isRoot1OfAffine1 ? root1 : root2).toTex()}]$ et ${affine1.a > 0 ? "positif" : "négatif"} sur $[${(isRoot1OfAffine1 ? root1 : root2).toTex()}; +\\infty[$.
+
+On résout ensuite l'inéquation $${affine2.toTree().toTex()} > 0$ :
+
+$$
+${firstDegreeInequationResolutionTex(affine2, ">", new NumberNode(0))}
+$$
+  
+On en déduit que $${affine2.toTree().toTex()}$ est ${affine2.a > 0 ? "négatif" : "positif"} sur $]-\\infty; ${(isRoot1OfAffine1 ? root2 : root1).toTex()}]$ et ${affine2.a > 0 ? "positif" : "négatif"} sur $[${(isRoot1OfAffine1 ? root2 : root1).toTex()}; +\\infty[$.
+
+En utilisant la règle des signes, on en déduit alors que $f$ est ${signs3[0]} sur $]\\infty; ${root1.toTex()}]$, puis ${signs3[1]} sur $[${root1.toTex()}; ${root2.toTex()}[$, puis ${signs3[2]} sur $[${root2.toTex()}; +\\infty[$.
+`;
+};
+const getKeys = (identifiers) => {
+    return ["infty"];
+};
+const isAnswerTableValid = (ans, { answerTable, affine1Coeffs, affine2Coeffs }) => {
+    try {
+        const firstRowVea = ans[0].every((cell, j) => j === 3 || j === 5
+            ? parseAlgebraic(cell)
+                .simplify({ decimalToFractions: true })
+                .toTex() === answerTable[0][j]
+            : cell === answerTable[0][j]);
+        if (!firstRowVea)
+            return false;
+        const lastRowVEA = ans[3].every((cell, j) => cell === answerTable[3][j]);
+        if (!lastRowVEA)
+            return false;
+        const secondVEA = rowTableVEA(ans[1], answerTable[1], affine1Coeffs);
+        if (!secondVEA)
+            return false;
+        const thirdVEA = rowTableVEA(ans[2], answerTable[2], affine2Coeffs);
+        if (!thirdVEA)
+            return false;
+        return true;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const rowTableVEA = (row, answerRow, affineCoeffs) => {
+    const signs = affineCoeffs[1] > 0 ? ["-", "+"] : ["+", "-"];
+    const zero = row.indexOf("0");
+    if (!zero || answerRow[zero] !== "0")
+        return false;
+    const left = row.slice(1, zero);
+    const right = row.slice(zero + 1);
+    const leftGood = left.some((e) => e === signs[0]) &&
+        left.every((e) => e === signs[0] || e == "\\ " || e === "");
+    const rightGood = right.some((e) => e === signs[1]) &&
+        right.every((e) => e === signs[1] || e == "\\ " || e === "");
+    if (!leftGood || !rightGood)
+        return false;
+    return true;
+};
+const getTestSignTableQuestion = (ops) => {
+    let a = 0;
+    let b = 0;
+    let c = 0;
+    let d = 0;
+    do {
+        a = randint(-10, 10, [0]);
+        b = randint(-10, 10);
+        c = randint(-10, 10, [0]);
+        d = randint(-10, 10);
+    } while (c * b === a * d);
+    const affine1 = new Affine(a, b);
+    const affine2 = new Affine(c, d);
+    const initTable = [
+        ["$x$", "", "\\ ", "", "\\ ", "", "\\ ", ""],
+        [`$${affine1.toTree().toTex()}$`, "\\ ", "", "", "", "", "", "\\ "],
+        [`$${affine2.toTree().toTex()}$`, "\\ ", "", "", "", "", "", "\\ "],
+        [`$f(x)$`, "\\ ", "", "", "", "", "", "\\ "],
+    ];
+    const identifiers = {
+        affine1Coeffs: [b, a],
+        affine2Coeffs: [d, c],
+        initTable,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: identifiers.initTable,
+    };
+};
+export const affineProductSignTable = {
+    id: "affineProductSignTable",
+    label: "Dresser le tableau de signes d'un produit de fonctions affines",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTestSignTableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "signTable",
+};

package/lib/exercises/math/functions/sign/affineSignTable.d.ts

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

package/lib/exercises/math/functions/sign/affineSignTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affineSignTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/affineSignTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;CACvB,CAAC;AAwGF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAkBjD,CAAC"}