math-exercises 2.2.90 → 2.2.91

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

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.affineAdjustmentExercise = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
 const randint_1 = require("../../../../math/utils/random/randint");
 const round_1 = require("../../../../math/utils/round");
+const leastSquares_1 = require("../../../../math/utils/stats/leastSquares");
 const equalNode_1 = require("../../../../tree/nodes/equations/equalNode");
 const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
 const addNode_1 = require("../../../../tree/nodes/operators/addNode");
@@ -41,23 +43,22 @@ function generateLinearData(n) {
     }
     return data;
 }
+const getAnswer = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const { a, b } = (0, leastSquares_1.leastSquares)(xValues, yValues);
+    const aFixed = (0, round_1.round)(a, 1);
+    const bFixed = (0, round_1.round)(b, 1);
+    const answer = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(aFixed), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bFixed)).simplify({ forbidFactorize: true })).toTex();
+    return answer;
+};
 const getAffineAdjustmentQuestion = () => {
     const data = generateLinearData(6);
     data.sort((a, b) => a.x - b.x);
     const xValues = data.map((point) => point.x);
     const yValues = data.map((point) => point.y);
-    const G1x = (0, round_1.round)((xValues[0] + xValues[1] + xValues[2]) / 3, 1);
-    const G2x = (0, round_1.round)((xValues[3] + xValues[4] + xValues[5]) / 3, 1);
-    const G1y = (0, round_1.round)((yValues[0] + yValues[1] + yValues[2]) / 3, 1);
-    const G2y = (0, round_1.round)((yValues[3] + yValues[4] + yValues[5]) / 3, 1);
-    const a = (G2y - G1y) / (G2x - G1x);
-    const afixed = (0, round_1.round)(a, 1);
-    const b = G2y - a * G2x;
-    const bfixed = (0, round_1.round)(b, 1);
-    const answer = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(afixed), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bfixed)).simplify({ forbidFactorize: true })).toTex();
-    const identifiers = { G1x, G2x, G1y, G2y, xValues, yValues };
+    const identifiers = { xValues, yValues };
     const question = {
-        answer: answer,
+        answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: ["equal", "y", "x", "a", "b"],
         answerFormat: "tex",
@@ -66,18 +67,17 @@ const getAffineAdjustmentQuestion = () => {
     };
     return question;
 };
-const getPropositions = (n, { answer, G1x, G2x, G1y, G2y }) => {
+const getPropositions = (n, { answer, xValues, yValues }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer, "tex");
-    const a = (G2y - G1y) / (G2x - G1x);
-    const afixed = (0, round_1.round)(a, 1);
-    const b = G2y - a * G2x;
-    const bfixed = (0, round_1.round)(b, 1);
-    const wrongAnswer1 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new substractNode_1.SubstractNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(afixed), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bfixed)).simplify({ forbidFactorize: true }));
-    const awrong = (G2x - G1x) / (G2y - G1y);
-    const bwrong = G1y - a * G1x;
-    const wrongAnswer2 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode((0, round_1.round)(awrong, 1)), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bfixed)).simplify({ forbidFactorize: true }));
-    const wrongAnswer3 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(afixed), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode((0, round_1.round)(bwrong, 1))).simplify({ forbidFactorize: true }));
+    const { a, b } = (0, leastSquares_1.leastSquares)(xValues, yValues);
+    const aFixed = (0, round_1.round)(a, 1);
+    const bFixed = (0, round_1.round)(b, 1);
+    const wrongAnswer1 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new substractNode_1.SubstractNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(aFixed), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bFixed)).simplify({ forbidFactorize: true }));
+    const awrong = (0, randfloat_1.randfloat)(-5, 5, 1, [0]);
+    const bwrong = (0, randfloat_1.randfloat)(-20, 20, 1);
+    const wrongAnswer2 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode((0, round_1.round)(awrong, 1)), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bFixed)).simplify({ forbidFactorize: true }));
+    const wrongAnswer3 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(aFixed), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode((0, round_1.round)(bwrong, 1))).simplify({ forbidFactorize: true }));
     const wrongAnswer4 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode((0, round_1.round)(awrong, 1)), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode((0, round_1.round)(bwrong, 1))).simplify({ forbidFactorize: true }));
     (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer1.toTex());
     (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer2.toTex());
@@ -91,12 +91,11 @@ const getPropositions = (n, { answer, G1x, G2x, G1y, G2y }) => {
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
-const isAnswerValid = (ans, { G1x, G2x, G1y, G2y }) => {
-    const a = (G2y - G1y) / (G2x - G1x);
-    const afixed = (0, round_1.round)(a, 1);
-    const b = G2y - a * G2x;
-    const bfixed = (0, round_1.round)(b, 1);
-    const valid = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(afixed), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bfixed)).simplify({ forbidFactorize: true }));
+const isAnswerValid = (ans, { answer, xValues, yValues }) => {
+    const { a, b } = (0, leastSquares_1.leastSquares)(xValues, yValues);
+    const aFixed = (0, round_1.round)(a, 1);
+    const bFixed = (0, round_1.round)(b, 1);
+    const valid = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(aFixed), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bFixed)).simplify({ forbidFactorize: true }));
     const latexs = valid.toAllValidTexs({ allowRawRightChildAsSolution: true });
     return latexs.includes(ans);
 };
@@ -113,4 +112,5 @@ exports.affineAdjustmentExercise = {
     isAnswerValid,
     subject: "Mathématiques",
     getInstruction,
+    getAnswer,
 };

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

@@ -1,10 +1,5 @@
 import { Exercise } from "../../../../exercises/exercise";
 type Identifiers = {
-    G1x: number;
-    G2x: number;
-    G2y: number;
-    G1y: number;
-    rSquared: number;
     xValues: number[];
     yValues: number[];
 };

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

@@ -1 +1 @@
-{"version":3,"file":"affineAdjustmentComplete.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineAdjustmentComplete.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAiBlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAmLF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAelE,CAAC"}
+{"version":3,"file":"affineAdjustmentComplete.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineAdjustmentComplete.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAqBlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAoJF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAiBlE,CAAC"}

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

@@ -3,8 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.affineAdjustmentCompleteExercise = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
 const randint_1 = require("../../../../math/utils/random/randint");
 const round_1 = require("../../../../math/utils/round");
+const generateAffineCloud_1 = require("../../../../math/utils/stats/generateAffineCloud");
+const leastSquares_1 = require("../../../../math/utils/stats/leastSquares");
+const rSquared_1 = require("../../../../math/utils/stats/rSquared");
 const equalNode_1 = require("../../../../tree/nodes/equations/equalNode");
 const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
 const addNode_1 = require("../../../../tree/nodes/operators/addNode");
@@ -14,81 +18,58 @@ const substractNode_1 = require("../../../../tree/nodes/operators/substractNode"
 const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
 const dollarize_1 = require("../../../../utils/latex/dollarize");
 const mdTable_1 = require("../../../../utils/markdown/mdTable");
-function generateLinearData(n) {
-    const slope = (0, randint_1.randint)(-500, 500, [0]) / 100;
-    const intercept = (0, randint_1.randint)(100, 5000) / 100;
-    let data = [];
-    let generatedXs = new Set();
-    while (data.length < n) {
-        let x = (0, randint_1.randint)(1, 100);
-        while (generatedXs.has(x)) {
-            x = (0, randint_1.randint)(1, 100);
-        }
-        generatedXs.add(x);
-        let noise = Math.random() * 100;
-        let y = (0, round_1.round)(slope * x + intercept + noise, 2);
-        data.push({ x, y });
-    }
-    return data;
-}
-function calculateRSquared(xValues, yValues) {
-    const n = xValues.length;
-    const sumX = xValues.reduce((acc, x) => acc + x, 0);
-    const sumY = yValues.reduce((acc, y) => acc + y, 0);
-    const sumXY = xValues.reduce((acc, x, i) => acc + x * yValues[i], 0);
-    const sumX2 = xValues.reduce((acc, x) => acc + x * x, 0);
-    const sumY2 = yValues.reduce((acc, y) => acc + y * y, 0);
-    const numerator = n * sumXY - sumX * sumY;
-    const denominator = Math.sqrt((n * sumX2 - sumX * sumX) * (n * sumY2 - sumY * sumY));
-    const r = numerator / denominator;
-    const rSquared = r * r;
-    return (0, round_1.round)(rSquared, 2);
-}
+const getAnswer = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const { a, b } = (0, leastSquares_1.leastSquares)(xValues, yValues);
+    const aFixed = (0, round_1.round)(a, 1);
+    const bFixed = (0, round_1.round)(b, 1);
+    const answerEq = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(aFixed), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bFixed)).simplify({ forbidFactorize: true })).toTex();
+    const r2 = (0, round_1.round)((0, rSquared_1.rSquared)(xValues, yValues), 2);
+    const answerR = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), r2.toTree()).toTex();
+    return `${answerEq}\\newline ${answerR}`;
+};
+const getInstruction = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const dataTable = (0, mdTable_1.mdTable)([
+        ["$x$", ...xValues.map((n) => (0, dollarize_1.dollarize)(n.frenchify()))],
+        ["$y$", ...yValues.map((n) => (0, dollarize_1.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 = generateLinearData(6);
+    const data = (0, generateAffineCloud_1.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 G1x = (0, round_1.round)((xValues[0] + xValues[1] + xValues[2]) / 3, 1);
-    const G2x = (0, round_1.round)((xValues[3] + xValues[4] + xValues[5]) / 3, 1);
-    const G1y = (0, round_1.round)((yValues[0] + yValues[1] + yValues[2]) / 3, 1);
-    const G2y = (0, round_1.round)((yValues[3] + yValues[4] + yValues[5]) / 3, 1);
-    const rSquared = calculateRSquared(xValues, yValues);
-    const a = (G2y - G1y) / (G2x - G1x);
-    const afixed = (0, round_1.round)(a, 1);
-    const b = G2y - a * G2x;
-    const bfixed = (0, round_1.round)(b, 1);
-    const answerEq = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(afixed), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bfixed)).simplify({ forbidFactorize: true })).toTex();
-    const answerR = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), rSquared.toTree()).toTex();
-    let dataTable = (0, mdTable_1.mdTable)([
-        ["$x$", ...xValues.map((n) => (0, dollarize_1.dollarize)(n.frenchify()))],
-        ["$y$", ...yValues.map((n) => (0, dollarize_1.dollarize)(n.frenchify()))],
-    ]);
+    const identifiers = {
+        xValues,
+        yValues,
+    };
     const question = {
-        answer: `${answerEq}\\newline ${answerR}`,
-        instruction: `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}
-`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { G1x, G2x, G1y, G2y, rSquared, xValues, yValues },
+        identifiers,
         style: { tableHasNoHeader: true },
     };
     return question;
 };
-const getPropositions = (n, { answer, G1x, G2x, G1y, G2y, rSquared }) => {
+const getPropositions = (n, { answer, xValues, yValues }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer, "tex");
-    const a = (G2y - G1y) / (G2x - G1x);
-    const afixed = (0, round_1.round)(a, 1);
-    const b = G2y - a * G2x;
-    const bfixed = (0, round_1.round)(b, 1);
-    const answerEq = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(afixed), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bfixed)).simplify({ forbidFactorize: true })).toTex();
-    const answerR = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), rSquared.toTree()).toTex();
-    const wrongAnswerEq1 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new substractNode_1.SubstractNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(afixed), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bfixed)).simplify({ forbidFactorize: true })).toTex();
-    const awrong = (G2x - G1x) / (G2y - G1y);
-    const wrongAnswerEq2 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode((0, round_1.round)(awrong, 1)), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bfixed)).simplify({ forbidFactorize: true })).toTex();
-    const wrongAnswerR1 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("R"), rSquared.toTree()).toTex();
-    const wrongAnswerR2 = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), (rSquared + 0.01).toTree()).toTex();
+    const { a, b } = (0, leastSquares_1.leastSquares)(xValues, yValues);
+    const r2 = (0, round_1.round)((0, rSquared_1.rSquared)(xValues, yValues), 2);
+    const aFixed = (0, round_1.round)(a, 1);
+    const bFixed = (0, round_1.round)(b, 1);
+    const answerEq = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(aFixed), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bFixed)).simplify({ forbidFactorize: true })).toTex();
+    const answerR = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), r2.toTree()).toTex();
+    const wrongAnswerEq1 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new substractNode_1.SubstractNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(aFixed), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bFixed)).simplify({ forbidFactorize: true })).toTex();
+    const awrong = (0, randfloat_1.randfloat)(1, 10, 1);
+    const wrongAnswerEq2 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode((0, round_1.round)(awrong, 1)), new variableNode_1.VariableNode("x")), new numberNode_1.NumberNode(bFixed)).simplify({ forbidFactorize: true })).toTex();
+    const wrongAnswerR1 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("R"), r2.toTree()).toTex();
+    const wrongAnswerR2 = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), (r2 + 0.01).toTree()).toTex();
     const wrongAnswer1 = `${answerEq}\\newline ${wrongAnswerR1}`;
     const wrongAnswer2 = `${answerEq}\\newline ${wrongAnswerR2}`;
     const wrongAnswer3 = `${wrongAnswerEq1}\\newline ${answerR}`;
@@ -123,4 +104,6 @@ exports.affineAdjustmentCompleteExercise = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
 };

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

@@ -1,6 +1,5 @@
 import { Exercise } from "../../../../exercises/exercise";
 type Identifiers = {
-    rSquared: number;
     xValues: number[];
     yValues: number[];
 };

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

@@ -1 +1 @@
-{"version":3,"file":"affineAdjustmentRsquared.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineAdjustmentRsquared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAiBlC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA2HF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAclE,CAAC"}
+{"version":3,"file":"affineAdjustmentRsquared.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineAdjustmentRsquared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,0BAA0B,CAAC;AAmBlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAqGF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAgBlE,CAAC"}

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

@@ -3,72 +3,53 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.affineAdjustmentRsquaredExercise = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
-const randint_1 = require("../../../../math/utils/random/randint");
 const round_1 = require("../../../../math/utils/round");
+const generateAffineCloud_1 = require("../../../../math/utils/stats/generateAffineCloud");
+const rSquared_1 = require("../../../../math/utils/stats/rSquared");
 const equalNode_1 = require("../../../../tree/nodes/equations/equalNode");
 const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
 const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
 const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
 const dollarize_1 = require("../../../../utils/latex/dollarize");
 const mdTable_1 = require("../../../../utils/markdown/mdTable");
-function generateLinearData(n) {
-    const slope = (0, randint_1.randint)(-500, 500, [0]) / 100;
-    const intercept = (0, randint_1.randint)(100, 5000) / 100;
-    let data = [];
-    let generatedXs = new Set();
-    while (data.length < n) {
-        let x = (0, randint_1.randint)(1, 100);
-        while (generatedXs.has(x)) {
-            x = (0, randint_1.randint)(1, 100);
-        }
-        generatedXs.add(x);
-        let noise = Math.random() * 100;
-        let y = (0, round_1.round)(slope * x + intercept + noise, 2);
-        data.push({ x, y });
-    }
-    return data;
-}
-function calculateRSquared(xValues, yValues) {
-    const n = xValues.length;
-    const sumX = xValues.reduce((acc, x) => acc + x, 0);
-    const sumY = yValues.reduce((acc, y) => acc + y, 0);
-    const sumXY = xValues.reduce((acc, x, i) => acc + x * yValues[i], 0);
-    const sumX2 = xValues.reduce((acc, x) => acc + x * x, 0);
-    const sumY2 = yValues.reduce((acc, y) => acc + y * y, 0);
-    const numerator = n * sumXY - sumX * sumY;
-    const denominator = Math.sqrt((n * sumX2 - sumX * sumX) * (n * sumY2 - sumY * sumY));
-    const r = numerator / denominator;
-    const rSquared = r * r;
-    return (0, round_1.round)(rSquared, 2);
-}
-const getAffineAdjustmentRsquaredQuestion = () => {
-    const data = generateLinearData(6);
-    data.sort((a, b) => a.x - b.x);
-    const xValues = data.map((point) => (0, round_1.round)(point.x, 1));
-    const yValues = data.map((point) => (0, round_1.round)(point.y, 1));
-    const rSquared = calculateRSquared(xValues, yValues);
-    const answer = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), rSquared.toTree()).toTex();
+const getInstruction = (identifiers) => {
+    const { xValues, yValues } = identifiers;
     let dataTable = (0, mdTable_1.mdTable)([
         ["$x$", ...xValues.map((n) => (0, dollarize_1.dollarize)(n.frenchify()))],
         ["$y$", ...yValues.map((n) => (0, dollarize_1.dollarize)(n.frenchify()))],
     ]);
+    return `On considère la série statistique ci-dessous. Déterminez la valeur du coefficient de détermination. ${dataTable}
+`;
+};
+const getAnswer = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const r2 = (0, round_1.round)((0, rSquared_1.rSquared)(xValues, yValues), 2);
+    const answer = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), r2.toTree()).toTex();
+    return answer;
+};
+const getAffineAdjustmentRsquaredQuestion = () => {
+    const data = (0, generateAffineCloud_1.generateAffineCloud)(6);
+    data.sort((a, b) => a.x - b.x);
+    const xValues = data.map((point) => (0, round_1.round)(point.x, 1));
+    const yValues = data.map((point) => (0, round_1.round)(point.y, 1));
+    const identifiers = { xValues, yValues };
     const question = {
-        answer: answer,
-        instruction: `On considère la série statistique ci-dessous. Déterminez la valeur du coefficient de détermination. ${dataTable}
-`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["R", "equal"],
         answerFormat: "tex",
-        identifiers: { rSquared, xValues, yValues },
+        identifiers,
         style: { tableHasNoHeader: true },
     };
     return question;
 };
-const getPropositions = (n, { answer, rSquared }) => {
+const getPropositions = (n, { answer, xValues, yValues }) => {
     const propositions = [];
+    const r2 = (0, round_1.round)((0, rSquared_1.rSquared)(xValues, yValues), 2);
     (0, exercise_1.addValidProp)(propositions, answer, "tex");
-    const wrongAnswer1 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("R"), rSquared.toTree()).toTex();
-    const wrongAnswer2 = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), (rSquared + 0.01).toTree()).toTex();
-    const wrongAnswer3 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("R"), (rSquared - 0.01).toTree()).toTex();
+    const wrongAnswer1 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("R"), r2.toTree()).toTex();
+    const wrongAnswer2 = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), (r2 + 0.01).toTree()).toTex();
+    const wrongAnswer3 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("R"), (r2 - 0.01).toTree()).toTex();
     (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer1);
     (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer2);
     (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer3);
@@ -78,8 +59,9 @@ const getPropositions = (n, { answer, rSquared }) => {
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
-const isAnswerValid = (ans, { rSquared }) => {
-    const validanswer = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), rSquared.toTree());
+const isAnswerValid = (ans, { xValues, yValues }) => {
+    const r2 = (0, round_1.round)((0, rSquared_1.rSquared)(xValues, yValues), 2);
+    const validanswer = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), r2.toTree());
     const latexs = validanswer.toAllValidTexs({
         allowRawRightChildAsSolution: true,
         allowFractionToDecimal: true,
@@ -98,4 +80,6 @@ exports.affineAdjustmentRsquaredExercise = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
 };

package/lib/exercises/math/matrices/productCell.js

@@ -4,7 +4,7 @@ exports.productCell = void 0;
 const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const randint_1 = require("../../../math/utils/random/randint");
-const sum_1 = require("../../../math/utils/sum");
+const sum_1 = require("../../../math/utils/stats/sum");
 const addNode_1 = require("../../../tree/nodes/operators/addNode");
 const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
 const variableNode_1 = require("../../../tree/nodes/variables/variableNode");

package/lib/exercises/math/probaStat/probaFromTableWithContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AA2IF,KAAK,OAAO,GAAG;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAsBF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBpE,CAAC"}
+{"version":3,"file":"probaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AA4IF,KAAK,OAAO,GAAG;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAsBF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBpE,CAAC"}

package/lib/exercises/math/probaStat/stats1var/interquartilesList.js

@@ -4,7 +4,7 @@ exports.interquartilesList = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const numberVEA_1 = require("../../../../exercises/vea/numberVEA");
-const quartiles_1 = require("../../../../math/utils/quartiles");
+const quartiles_1 = require("../../../../math/utils/stats/quartiles");
 const randint_1 = require("../../../../math/utils/random/randint");
 const approxOrEqual_1 = require("../../../../utils/latex/approxOrEqual");
 const getPropositions = (n, { answer }) => {

package/lib/exercises/math/probaStat/stats1var/interquartilesTable.js

@@ -4,7 +4,7 @@ exports.interquartilesTable = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const numberVEA_1 = require("../../../../exercises/vea/numberVEA");
-const quartiles_1 = require("../../../../math/utils/quartiles");
+const quartiles_1 = require("../../../../math/utils/stats/quartiles");
 const randint_1 = require("../../../../math/utils/random/randint");
 const approxOrEqual_1 = require("../../../../utils/latex/approxOrEqual");
 const mdTable_1 = require("../../../../utils/markdown/mdTable");

package/lib/exercises/math/probaStat/stats1var/standardDeviationList.js

@@ -7,8 +7,8 @@ const sqrtVEA_1 = require("../../../../exercises/vea/sqrtVEA");
 const randfloat_1 = require("../../../../math/utils/random/randfloat");
 const randint_1 = require("../../../../math/utils/random/randint");
 const round_1 = require("../../../../math/utils/round");
-const standardDeviation_1 = require("../../../../math/utils/standardDeviation");
-const variance_1 = require("../../../../math/utils/variance");
+const standardDeviation_1 = require("../../../../math/utils/stats/standardDeviation");
+const variance_1 = require("../../../../math/utils/stats/variance");
 const average_1 = require("../../../../utils/average");
 const alignTex_1 = require("../../../../utils/latex/alignTex");
 const approxOrEqual_1 = require("../../../../utils/latex/approxOrEqual");

package/lib/exercises/math/probaStat/stats1var/standardDeviationTable.js

@@ -7,8 +7,8 @@ const sqrtVEA_1 = require("../../../../exercises/vea/sqrtVEA");
 const randfloat_1 = require("../../../../math/utils/random/randfloat");
 const randint_1 = require("../../../../math/utils/random/randint");
 const round_1 = require("../../../../math/utils/round");
-const standardDeviation_1 = require("../../../../math/utils/standardDeviation");
-const variance_1 = require("../../../../math/utils/variance");
+const standardDeviation_1 = require("../../../../math/utils/stats/standardDeviation");
+const variance_1 = require("../../../../math/utils/stats/variance");
 const average_1 = require("../../../../utils/average");
 const alignTex_1 = require("../../../../utils/latex/alignTex");
 const approxOrEqual_1 = require("../../../../utils/latex/approxOrEqual");

package/lib/exercises/math/probaStat/stats1var/varianceList.js

@@ -7,7 +7,7 @@ const rationalVEA_1 = require("../../../../exercises/vea/rationalVEA");
 const randfloat_1 = require("../../../../math/utils/random/randfloat");
 const randint_1 = require("../../../../math/utils/random/randint");
 const round_1 = require("../../../../math/utils/round");
-const variance_1 = require("../../../../math/utils/variance");
+const variance_1 = require("../../../../math/utils/stats/variance");
 const average_1 = require("../../../../utils/average");
 const alignTex_1 = require("../../../../utils/latex/alignTex");
 const approxOrEqual_1 = require("../../../../utils/latex/approxOrEqual");

package/lib/exercises/math/probaStat/stats1var/varianceTable.js

@@ -7,7 +7,7 @@ const rationalVEA_1 = require("../../../../exercises/vea/rationalVEA");
 const randfloat_1 = require("../../../../math/utils/random/randfloat");
 const randint_1 = require("../../../../math/utils/random/randint");
 const round_1 = require("../../../../math/utils/round");
-const variance_1 = require("../../../../math/utils/variance");
+const variance_1 = require("../../../../math/utils/stats/variance");
 const average_1 = require("../../../../utils/average");
 const alignTex_1 = require("../../../../utils/latex/alignTex");
 const approxOrEqual_1 = require("../../../../utils/latex/approxOrEqual");

package/lib/index.d.ts

@@ -640,22 +640,12 @@ declare const mathExercises: (Exercise<{
     b: number;
     isAskingA: boolean;
 }, {}> | Exercise<{
-    G1x: number;
-    G2x: number;
-    G2y: number;
-    G1y: number;
     xValues: number[];
     yValues: number[];
 }, {}> | Exercise<{
-    rSquared: number;
     xValues: number[];
     yValues: number[];
 }, {}> | Exercise<{
-    G1x: number;
-    G2x: number;
-    G2y: number;
-    G1y: number;
-    rSquared: number;
     xValues: number[];
     yValues: number[];
 }, {}> | Exercise<{

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/geometry/CloudPoints.js

@@ -8,8 +8,8 @@ const variableNode_1 = require("../../tree/nodes/variables/variableNode");
 const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const addNode_1 = require("../../tree/nodes/operators/addNode");
 const randint_1 = require("../utils/random/randint");
-const covariance_1 = require("../utils/covariance");
-const variance_1 = require("../utils/variance");
+const covariance_1 = require("../utils/stats/covariance");
+const variance_1 = require("../utils/stats/variance");
 class CloudPointsConstructor {
     static random(nbPoints) {
         const names = [];

package/lib/math/probability/binomial.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Binomial = void 0;
 const combination_1 = require("../utils/combinatorics/combination");
-const sum_1 = require("../utils/sum");
+const sum_1 = require("../utils/stats/sum");
 class Binomial {
     constructor(n, p) {
         this.n = n;

package/lib/math/utils/round.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"round.d.ts","sourceRoot":"","sources":["../../../src/math/utils/round.ts"],"names":[],"mappings":"AAEA,wBAAgB,KAAK,CACnB,CAAC,EAAE,MAAM,EACT,SAAS,EAAE,MAAM,EACjB,YAAY,CAAC,EAAE,OAAO,GACrB,MAAM,CAKR;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,UAK5D"}
+{"version":3,"file":"round.d.ts","sourceRoot":"","sources":["../../../src/math/utils/round.ts"],"names":[],"mappings":"AAAA,wBAAgB,KAAK,CACnB,CAAC,EAAE,MAAM,EACT,SAAS,EAAE,MAAM,EACjB,YAAY,CAAC,EAAE,OAAO,GACrB,MAAM,CAqBR;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,UAG5D"}

package/lib/math/utils/round.js

@@ -1,15 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.roundSignificant = exports.round = void 0;
-const epsilon_1 = require("../numbers/epsilon");
 function round(x, precision, fillDecimals) {
-    return (Math.round((x + epsilon_1.EPSILON) * Math.pow(10, precision)) /
-        Math.pow(10, precision));
+    if (!("" + x).includes("e")) {
+        return +(Math.round(Number(x + "e+" + precision)) + "e-" + precision);
+    }
+    else {
+        const arr = ("" + x).split("e");
+        let sig = "";
+        if (+arr[1] + precision > 0) {
+            sig = "+";
+        }
+        return +(Math.round(Number(+arr[0] + "e" + sig + (+arr[1] + precision))) +
+            "e-" +
+            precision);
+    }
+    // return +(Math.round(Number(x + "e+" + precision)) + "e-" + precision);
+    // return (
+    //   Math.round((x + Number.EPSILON) * Math.pow(10, precision)) /
+    //   Math.pow(10, precision)
+    // );
 }
 exports.round = round;
 function roundSignificant(x, precision) {
-    const rounded = Math.round((x + epsilon_1.EPSILON) * Math.pow(10, precision)) /
-        Math.pow(10, precision);
+    const rounded = round(x, precision);
     return rounded.toFixed(precision).replace(".", ",");
 }
 exports.roundSignificant = roundSignificant;

package/lib/math/utils/stats/covariance.d.ts

@@ -0,0 +1,4 @@
+import { AlgebraicNode } from "../../../tree/nodes/algebraicNode";
+export declare function covXYAsNode(xValues: number[], avgX: AlgebraicNode, yValues: number[], avgY: AlgebraicNode): AlgebraicNode;
+export declare function covarianceXY(xValues: number[], avgX: number, yValues: number[], avgY: number): number;
+//# sourceMappingURL=covariance.d.ts.map

package/lib/math/utils/stats/covariance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"covariance.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/stats/covariance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAO/D,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,aAAa,GAClB,aAAa,CAef;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,MAAM,GACX,MAAM,CASR"}