math-exercises 3.0.187 → 3.0.189

package/lib/exercises/math/functions/affines/adjustment/affineAdjustment.js

@@ -0,0 +1,129 @@
+import { addValidProp, propWhile, 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 { round } from "../../../../../math/utils/round.js";
+import { leastSquares } from "../../../../../math/utils/stats/leastSquares.js";
+import { EqualNode } from "../../../../../tree/nodes/equations/equalNode.js";
+import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { AddNode } from "../../../../../tree/nodes/operators/addNode.js";
+import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { SubstractNode } from "../../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { dollarize } from "../../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../../utils/markdown/mdTable.js";
+const getInstruction = ({ xValues, yValues }) => {
+    const dataTable = mdTable([
+        ["$x$", ...xValues.map((n) => dollarize(n.frenchify()))],
+        ["$y$", ...yValues.map((n) => dollarize(n.frenchify()))],
+    ]);
+    return `On considère la série statistique ci-dessous. Déterminer l'équation de la droite d'ajustement obtenue par la méthode des moindres carrés. 
+
+${dataTable}
+
+Arrondir les coefficients au dixième.
+`;
+};
+function generateLinearData(n) {
+    const slope = randint(-500, 500, [0]) / 100;
+    const intercept = randint(100, 5000) / 100;
+    const data = [];
+    const generatedXs = new Set();
+    let counter = 0;
+    while (data.length < n) {
+        counter++;
+        if (counter > 1000) {
+            throw new Error("affineAdjustement too many iterations");
+        }
+        let x = randint(1, 100);
+        let cnt = 0;
+        while (generatedXs.has(x)) {
+            cnt++;
+            if (cnt > 1000) {
+                throw new Error("affineAdjustement too many iterations");
+            }
+            x = randint(1, 100);
+        }
+        generatedXs.add(x);
+        const y = round(slope * x + intercept, 2);
+        data.push({ x, y });
+    }
+    return data;
+}
+const getAnswer = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const { a, b } = leastSquares(xValues, yValues);
+    const aFixed = round(a, 1);
+    const bFixed = round(b, 1);
+    const answer = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(aFixed), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true })).toTex();
+    return answer;
+};
+const getAffineAdjustmentQuestion = () => {
+    const data = generateLinearData(5);
+    data.sort((a, b) => a.x - b.x);
+    const xValues = data.map((point) => point.x);
+    const yValues = data.map((point) => point.y);
+    const identifiers = { xValues, yValues };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["equal", "y", "x", "a", "b"],
+        answerFormat: "tex",
+        identifiers,
+        style: {
+            tableOptions: {
+                firstCellIsDivided: false,
+                firstColumnIsHeader: true,
+                firstRowIsHeader: false,
+            },
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, xValues, yValues }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "tex");
+    const { a, b } = leastSquares(xValues, yValues);
+    const aFixed = round(a, 1);
+    const bFixed = round(b, 1);
+    const wrongAnswer1 = new EqualNode(new VariableNode("y"), new SubstractNode(new MultiplyNode(new NumberNode(aFixed), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true }));
+    const awrong = randfloat(-5, 5, 1, [0]);
+    const bwrong = randfloat(-20, 20, 1);
+    const wrongAnswer2 = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(round(awrong, 1)), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true }));
+    const wrongAnswer3 = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(aFixed), new VariableNode("x")), new NumberNode(round(bwrong, 1))).simplify({ forbidFactorize: true }));
+    const wrongAnswer4 = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(round(awrong, 1)), new VariableNode("x")), new NumberNode(round(bwrong, 1))).simplify({ forbidFactorize: true }));
+    tryToAddWrongProp(propositions, wrongAnswer1.toTex());
+    tryToAddWrongProp(propositions, wrongAnswer2.toTex());
+    tryToAddWrongProp(propositions, wrongAnswer3.toTex());
+    tryToAddWrongProp(propositions, wrongAnswer4.toTex());
+    propWhile(propositions, n, () => {
+        const a = randint(-10, 10, [0]);
+        const b = randint(-10, 10);
+        const wrongAnswer = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(a), new VariableNode("x")), new NumberNode(b)).simplify({ forbidFactorize: true }));
+        tryToAddWrongProp(propositions, wrongAnswer.toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { xValues, yValues }) => {
+    const { a, b } = leastSquares(xValues, yValues);
+    const aFixed = round(a, 1);
+    const bFixed = round(b, 1);
+    const valid = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(aFixed), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true }));
+    const latexs = valid.toAllValidTexs({ allowRawRightChildAsSolution: true });
+    return latexs.includes(ans);
+};
+export const affineAdjustmentExercise = {
+    id: "affineAdjustment",
+    label: "Déterminer l'équation de la droite d'ajustement à partir d'un tableau de données",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getAffineAdjustmentQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/functions/affines/adjustment/affineAdjustmentComplete.d.ts

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

package/lib/exercises/math/functions/affines/adjustment/affineAdjustmentComplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affineAdjustmentComplete.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/affines/adjustment/affineAdjustmentComplete.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA4JF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAalE,CAAC"}

package/lib/exercises/math/functions/affines/adjustment/affineAdjustmentComplete.js

@@ -0,0 +1,108 @@
+import { addValidProp, propWhile, 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 { round } from "../../../../../math/utils/round.js";
+import { generateAffineCloud } from "../../../../../math/utils/stats/generateAffineCloud.js";
+import { leastSquares } from "../../../../../math/utils/stats/leastSquares.js";
+import { rSquared } from "../../../../../math/utils/stats/rSquared.js";
+import { EqualNode } from "../../../../../tree/nodes/equations/equalNode.js";
+import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { AddNode } from "../../../../../tree/nodes/operators/addNode.js";
+import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { PowerNode } from "../../../../../tree/nodes/operators/powerNode.js";
+import { SubstractNode } from "../../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { dollarize } from "../../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../../utils/markdown/mdTable.js";
+const getAnswer = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const { a, b } = leastSquares(xValues, yValues);
+    const aFixed = round(a, 1);
+    const bFixed = round(b, 1);
+    const answerEq = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(aFixed), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true })).toTex();
+    const r2 = round(rSquared(xValues, yValues), 2);
+    const answerR = new EqualNode(new PowerNode(new VariableNode("R"), new NumberNode(2)), r2.toTree()).toTex();
+    return `${answerEq}\\newline ${answerR}`;
+};
+const getInstruction = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const dataTable = mdTable([
+        ["$x$", ...xValues.map((n) => dollarize(n.frenchify()))],
+        ["$y$", ...yValues.map((n) => dollarize(n.frenchify()))],
+    ]);
+    return `On considère la série statistique ci-dessous. A l'aide de la calculatrice, déterminer l'équation de la droite d'ajustement et la valeur du coefficient de détermination. ${dataTable}
+`;
+};
+const getAffineAdjustmentCompleteQuestion = () => {
+    const data = generateAffineCloud(6);
+    data.sort((a, b) => a.x - b.x);
+    const xValues = data.map((point) => point.x);
+    const yValues = data.map((point) => point.y);
+    const identifiers = {
+        xValues,
+        yValues,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        style: {
+            tableOptions: {
+                firstCellIsDivided: false,
+                firstColumnIsHeader: true,
+                firstRowIsHeader: false,
+            },
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, xValues, yValues }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "tex");
+    const { a, b } = leastSquares(xValues, yValues);
+    const r2 = round(rSquared(xValues, yValues), 2);
+    const aFixed = round(a, 1);
+    const bFixed = round(b, 1);
+    const answerEq = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(aFixed), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true })).toTex();
+    const answerR = new EqualNode(new PowerNode(new VariableNode("R"), new NumberNode(2)), r2.toTree()).toTex();
+    const wrongAnswerEq1 = new EqualNode(new VariableNode("y"), new SubstractNode(new MultiplyNode(new NumberNode(aFixed), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true })).toTex();
+    const awrong = randfloat(1, 10, 1);
+    const wrongAnswerEq2 = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(round(awrong, 1)), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true })).toTex();
+    const wrongAnswerR1 = new EqualNode(new VariableNode("R"), r2.toTree()).toTex();
+    const wrongAnswerR2 = new EqualNode(new PowerNode(new VariableNode("R"), new NumberNode(2)), (r2 + 0.01).toTree()).toTex();
+    const wrongAnswer1 = `${answerEq}\\newline ${wrongAnswerR1}`;
+    const wrongAnswer2 = `${answerEq}\\newline ${wrongAnswerR2}`;
+    const wrongAnswer3 = `${wrongAnswerEq1}\\newline ${answerR}`;
+    const wrongAnswer4 = `${wrongAnswerEq2}\\newline ${answerR}`;
+    tryToAddWrongProp(propositions, wrongAnswer1);
+    tryToAddWrongProp(propositions, wrongAnswer2);
+    tryToAddWrongProp(propositions, wrongAnswer3);
+    tryToAddWrongProp(propositions, wrongAnswer4);
+    propWhile(propositions, n, () => {
+        const a = randint(-10, 10, [0]);
+        const b = randint(-10, 10);
+        const wrongAnswerEq = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(a), new VariableNode("x")), new NumberNode(b)).simplify({ forbidFactorize: true })).toTex();
+        const wrongAnswerR = new EqualNode(new PowerNode(new VariableNode("R"), new NumberNode(2)), round(Math.random(), 2).toTree()).toTex();
+        const wrongAnswer = `${wrongAnswerEq}\\newline ${wrongAnswerR}`;
+        tryToAddWrongProp(propositions, wrongAnswer);
+    });
+    return shuffleProps(propositions, n);
+};
+export const affineAdjustmentCompleteExercise = {
+    id: "affineAdjustmentComplete",
+    label: "Déterminer l'équation de la droite d'ajustement et le coefficient de détermination",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getAffineAdjustmentCompleteQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+};

package/lib/exercises/math/functions/affines/adjustment/affineAdjustmentRsquared.d.ts

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

package/lib/exercises/math/functions/affines/adjustment/affineAdjustmentRsquared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affineAdjustmentRsquared.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/affines/adjustment/affineAdjustmentRsquared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAqHF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAalE,CAAC"}

package/lib/exercises/math/functions/affines/adjustment/affineAdjustmentRsquared.js

@@ -0,0 +1,92 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { round } from "../../../../../math/utils/round.js";
+import { generateAffineCloud } from "../../../../../math/utils/stats/generateAffineCloud.js";
+import { rSquared } from "../../../../../math/utils/stats/rSquared.js";
+import { EqualNode } from "../../../../../tree/nodes/equations/equalNode.js";
+import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { PowerNode } from "../../../../../tree/nodes/operators/powerNode.js";
+import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { dollarize } from "../../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../../utils/markdown/mdTable.js";
+const getInstruction = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const dataTable = mdTable([
+        ["$x$", ...xValues.map((n) => dollarize(n.frenchify()))],
+        ["$y$", ...yValues.map((n) => dollarize(n.frenchify()))],
+    ]);
+    return `On considère la série statistique ci-dessous : 
+  
+${dataTable}
+
+Déterminer la valeur du coefficient de détermination pour un ajustement affine de cette série. 
+`;
+};
+const getAnswer = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const r2 = round(rSquared(xValues, yValues), 2);
+    const answer = new EqualNode(new PowerNode(new VariableNode("R"), new NumberNode(2)), r2.toTree()).toTex();
+    return answer;
+};
+const getAffineAdjustmentRsquaredQuestion = () => {
+    const data = generateAffineCloud(6);
+    data.sort((a, b) => a.x - b.x);
+    const xValues = data.map((point) => round(point.x, 1));
+    const yValues = data.map((point) => round(point.y, 1));
+    const identifiers = { xValues, yValues };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["R", "equal"],
+        answerFormat: "tex",
+        identifiers,
+        style: {
+            tableOptions: {
+                firstCellIsDivided: false,
+                firstColumnIsHeader: true,
+                firstRowIsHeader: false,
+            },
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, xValues, yValues }) => {
+    const propositions = [];
+    const r2 = round(rSquared(xValues, yValues), 2);
+    addValidProp(propositions, answer, "tex");
+    const wrongAnswer1 = new EqualNode(new VariableNode("R"), r2.toTree()).toTex();
+    const wrongAnswer2 = new EqualNode(new PowerNode(new VariableNode("R"), new NumberNode(2)), (r2 + 0.01).toTree()).toTex();
+    const wrongAnswer3 = new EqualNode(new VariableNode("R"), (r2 - 0.01).toTree()).toTex();
+    tryToAddWrongProp(propositions, wrongAnswer1);
+    tryToAddWrongProp(propositions, wrongAnswer2);
+    tryToAddWrongProp(propositions, wrongAnswer3);
+    propWhile(propositions, n, () => {
+        const wrongAnswer = new EqualNode(new PowerNode(new VariableNode("R"), new NumberNode(1)), round(Math.random(), 2).toTree()).toTex();
+        tryToAddWrongProp(propositions, wrongAnswer);
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { xValues, yValues }) => {
+    const r2 = round(rSquared(xValues, yValues), 2);
+    const validanswer = new EqualNode(new PowerNode(new VariableNode("R"), new NumberNode(2)), r2.toTree());
+    const latexs = validanswer.toAllValidTexs({
+        allowRawRightChildAsSolution: true,
+        allowFractionToDecimal: true,
+    });
+    return latexs.includes(ans);
+};
+export const affineAdjustmentRsquaredExercise = {
+    id: "affineAdjustmentRsquared",
+    label: "Déterminer le coefficient de détermination à partir d'un tableau de données",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getAffineAdjustmentRsquaredQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,4 @@
+export * from "./affineAdjustment.js";
+export * from "./affineAdjustmentComplete.js";
+export * from "./affineAdjustmentRsquared.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/affines/adjustment/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from "./affineAdjustment.js";
+export * from "./affineAdjustmentComplete.js";
+export * from "./affineAdjustmentRsquared.js";

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

@@ -6,12 +6,8 @@ export * from "./affineExpressionReading.js";
 export * from "./interceptReading.js";
 export * from "./algebricExpressionOfAffine.js";
 export * from "./leadingCoeffAndOriginOrdinate.js";
-export * from "./affineAdjustment.js";
-export * from "./affineAdjustmentRsquared.js";
-export * from "./affineAdjustmentComplete.js";
 export * from "./affineMeanValue.js";
 export * from "./affineExpressionFromTwoImages.js";
-export * from "./affineFromExercise.js";
 export * from "./drawAffineFromLitExp.js";
 export * from "./recognizeExprAffine.js";
 export * from "./drawAffineFrom2Points.js";
@@ -24,4 +20,6 @@ export * from "./drawAffineFromPointAndLeadingCoeff.js";
 export * from "./drawAffineFromProgCalc.js";
 export * from "./placePointsFromAffine.js";
 export * from "./recognizeAffinePointsFromPoints.js";
+export * from "./adjustment/index.js";
+export * from "./situations/index.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;AACnD,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yCAAyC,CAAC;AACxD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,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;AAEnD,cAAc,sBAAsB,CAAC;AACrC,cAAc,oCAAoC,CAAC;AACnD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yCAAyC,CAAC;AACxD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AACrD,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}

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

@@ -6,12 +6,8 @@ export * from "./affineExpressionReading.js";
 export * from "./interceptReading.js";
 export * from "./algebricExpressionOfAffine.js";
 export * from "./leadingCoeffAndOriginOrdinate.js";
-export * from "./affineAdjustment.js";
-export * from "./affineAdjustmentRsquared.js";
-export * from "./affineAdjustmentComplete.js";
 export * from "./affineMeanValue.js";
 export * from "./affineExpressionFromTwoImages.js";
-export * from "./affineFromExercise.js";
 export * from "./drawAffineFromLitExp.js";
 export * from "./recognizeExprAffine.js";
 export * from "./drawAffineFrom2Points.js";
@@ -24,3 +20,5 @@ export * from "./drawAffineFromPointAndLeadingCoeff.js";
 export * from "./drawAffineFromProgCalc.js";
 export * from "./placePointsFromAffine.js";
 export * from "./recognizeAffinePointsFromPoints.js";
+export * from "./adjustment/index.js";
+export * from "./situations/index.js";

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

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

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

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

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

@@ -0,0 +1,219 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.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";
+import { affineModelisationSituations } from "./affineModelisationSituations.js";
+const situationsData = [
+    {
+        question: `Quelle est sa hauteur (en $\\textrm{cm}$) après $x$ jours ?`,
+        hint: `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.`,
+        correction: (initial, growth, answer) => `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 :
+
+$$
+${answer}\\ \\textrm{cm}
+$$`,
+    },
+    {
+        question: `Quel est le prix payé (en $€$) pour $x \\ \\textrm{km}$ parcourus ?`,
+        hint: `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.
+  `,
+        correction: (initial, growth, answer) => `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 : 
+
+$$
+${answer}\\ €
+$$`,
+    },
+    {
+        question: `Quelle sera la facture (en $€$) pour $x \\ \\textrm{kWh}$ consommés ?`,
+        hint: `Quel calcul permet de trouver la facture pour $10$ kWh consommés ?
+
+Inspire toi de ce calcul pour déterminer la facture pour $x$ kWh consommés.
+  `,
+        correction: (initial, growth, answer) => `Pour chaque kWh consommé, le prix augmente de $${growth.frenchify()}\\ €$. 
+Au bout de $x$ kWh, le prix augmente donc de $x\\times ${growth.frenchify()}\\ \\ €$.
+
+Le montant de l'abonnement fixe est de $${initial}\\ €$.
+
+Pour $x$ kWh consommés, la facture sera donc de : 
+
+$$
+${answer}\\ €
+$$`,
+    },
+    {
+        question: `Quelle sera la température (en °C) pour $x$ centaines de km parcourus vers le Sud ?`,
+        hint: `Quel calcul permet de trouver la température pour $2$ centaines de km parcourus ?
+
+Inspire toi de ce calcul pour déterminer la température pour $x$ centaines de km parcourus.
+  `,
+        correction: (initial, growth, answer) => `Pour chaque centaine de km parcourue, la température augmente de $${growth.frenchify()}$ °C. 
+Au bout de $x$ centaines de km, la température augmente donc de $x\\times ${growth.frenchify()}$ °C.
+
+Au départ, la température est de $${initial}$ °C.
+
+Pour $x$ centaines de km parcourus, la température sera donc de : 
+
+$$
+${answer}\\ \\textrm{°C}
+$$`,
+    },
+    {
+        question: `Quel sera son salaire net (en €) quand elle aura $x$ années d'ancienneté ?`,
+        hint: `Quel calcul permet de trouver son salaire net pour $10$ années d'ancienneté ?
+
+Inspire toi de ce calcul pour déterminer son salaire net pour $x$ années d'ancienneté.
+  `,
+        correction: (initial, growth, answer) => `Chaque année, son salaire net augmente de $${growth.frenchify()}\\ €$. 
+Au bout de $x$ années, son salaire net aura augmenté de $x\\times ${growth.frenchify()}\\ €$.
+
+Au départ, son salaire net était de $${initial}\\ €$.
+
+Pour $x$ années d'ancienneté, son salaire net sera donc de : 
+
+$$
+${answer}\\ \\textrm{€}
+$$`,
+    },
+    {
+        question: `Quel sera son score s'il commet $x$ erreurs ?`,
+        hint: `Quel calcul permet de trouver son score net pour $10$ erreurs ?
+
+Inspire toi de ce calcul pour déterminer son score pour $x$ erreurs.
+  `,
+        correction: (initial, growth, answer) => `Pour chaque erreur, son score baisse de $${Math.abs(growth).frenchify()}$ points. 
+Au bout de $x$ erreurs, son score aura baissé de $x\\times ${Math.abs(growth).frenchify()}$ points.
+
+Au départ, son score était de $${initial}$ points.
+
+Pour $x$ erreurs, son score sera donc de : 
+
+$$
+${answer}
+$$`,
+    },
+    {
+        question: `De combien disposera l'entreprise au bout de $x$ jours ?`,
+        hint: `Quel calcul permet de trouver ce dont dispose l'entreprise après $10$ jours ?
+
+Inspire toi de ce calcul pour déterminer ce dont elle dispose après $x$ jours.
+  `,
+        correction: (initial, growth, answer) => `Chaque jour, l'entreprise perd $${Math.abs(growth).frenchify()} \\ €$ de chiffres d'affaires.
+Au bout de $x$ jours, son chiffre d'affaires aura donc réduit de $x\\times ${Math.abs(growth).frenchify()}\\ €$.
+
+Au départ, l'entreprise faisait un chiffre d'affaires de $${initial}\\ €$.
+
+Après $x$ jours, l'entreprise aura donc un chiffre d'affaries  de : 
+
+$$
+${answer}\\ €
+$$`,
+    },
+    {
+        question: `Quelle sera la température (en $\\textrm{°C}$) au bout de $x$ jours ?`,
+        hint: `Quel calcul permet de trouver la température après $2$ jours ?
+
+Inspire toi de ce calcul pour déterminer la température après $x$ jours.
+  `,
+        correction: (initial, growth, answer) => `Chaque jour, la température baisse de $${Math.abs(growth).frenchify()}\\textrm{°C}$. 
+Au bout de $x$ jours, la température baissera donc de $x\\times ${Math.abs(growth).frenchify()}\\textrm{°C}$.
+
+Au départ, la température est de $${initial}\\textrm{°C}$.
+
+Après $x$ jours, la température sera donc de : 
+
+$$
+${answer}\\ \\textrm{°C}
+$$`,
+    },
+];
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { 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 { situationIndex, initial, growth } = identifiers;
+    const situation = affineModelisationSituations[situationIndex];
+    const situationData = situationsData[situationIndex];
+    return situation.context(initial, growth) + "\n \n" + situationData.question;
+};
+const getHint = (identifiers) => {
+    const { situationIndex } = identifiers;
+    const situation = situationsData[situationIndex];
+    return situation.hint;
+};
+const getCorrection = (identifiers) => {
+    const { situationIndex, initial, growth } = identifiers;
+    const situation = situationsData[situationIndex];
+    const answer = getAnswer(identifiers);
+    return situation.correction(initial, growth, answer);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return parseAlgebraic(ans)
+        .simplify()
+        .equals(parseAlgebraic(answer).simplify());
+};
+const getAffineFromExerciseQuestion = () => {
+    const situationIndex = randint(0, affineModelisationSituations.length);
+    const situation = affineModelisationSituations[situationIndex];
+    const initial = situation.randInitial();
+    const growth = situation.randGrowth();
+    const identifiers = {
+        id: situation.id,
+        situationIndex,
+        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,
+};