math-exercises 3.0.167 → 3.0.168

package/lib/exercises/math/probaStat/probaFromTableNoContext.js

@@ -54,12 +54,16 @@ const getProbaFromTableNoContextQuestion = (opts) => {
     const bBarreTotal = aBarreCapBBarre + aCapBBarre;
     let event = "";
     let proba = [];
-    const types = opts?.forbidConditionnal
-        ? ["singleEvent", "intersection", "union"]
-        : ["singleEvent", "intersection", "union", "conditionnal"];
-    const type = random(types);
+    const allowedTypes = opts?.probaTypes ?? [
+        "$P(A)$",
+        "$P(A\\cap B)$",
+        "$P(A\\cup B)$",
+        "$P_A(B)$",
+    ];
+    // "$P(A)$", "$P(A\\cap B)$", "$P(A\\cup B)$", "$P_A(B)$"
+    const type = random(allowedTypes);
     switch (type) {
-        case "singleEvent":
+        case "$P(A)$":
             [event, proba] = random([
                 ["P(A)", [aTotal, total]],
                 ["P(B)", [bTotal, total]],
@@ -67,7 +71,7 @@ const getProbaFromTableNoContextQuestion = (opts) => {
                 ["P(\\overline B)", [bBarreTotal, total]],
             ]);
             break;
-        case "intersection":
+        case "$P(A\\cap B)$":
             [event, proba] = random([
                 ["P(A\\cap B)", [aCapB, total]],
                 ["P(\\overline A\\cap B)", [aBarreCapB, total]],
@@ -75,7 +79,7 @@ const getProbaFromTableNoContextQuestion = (opts) => {
                 ["P(\\overline A \\cap \\overline B)", [aBarreCapBBarre, total]],
             ]);
             break;
-        case "union":
+        case "$P(A\\cup B)$":
             [event, proba] = random([
                 ["P(A\\cup B)", [total - aBarreCapBBarre, total]],
                 ["P(A\\cup \\overline B)", [total - aBarreCapB, total]],
@@ -83,7 +87,7 @@ const getProbaFromTableNoContextQuestion = (opts) => {
                 ["P(\\overline A \\cup \\overline B)", [total - aCapB, total]],
             ]);
             break;
-        case "conditionnal":
+        case "$P_A(B)$":
             [event, proba] = random([
                 ["P_A(B)", [aCapB, aTotal]],
                 ["P_A(\\overline B)", [aCapBBarre, aTotal]],
@@ -250,10 +254,12 @@ const getPropositions = (n, { answer, aBarreCapB, aBarreCapBBarre, aCapB, aCapBB
 };
 const options = [
     {
-        id: "forbidConditionnal",
-        label: "Ne pas utiliser les probabilités conditionnelles",
+        id: "probaTypes",
+        label: "Type de probabilité demandée",
         target: GeneratorOptionTarget.generation,
-        type: GeneratorOptionType.checkbox,
+        type: GeneratorOptionType.multiselect,
+        values: ["$P(A)$", "$P(A\\cap B)$", "$P(A\\cup B)$", "$P_A(B)$"],
+        defaultValue: ["$P(A)$", "$P(A\\cap B)$", "$P(A\\cup B)$", "$P_A(B)$"],
     },
 ];
 const isAnswerValid = (ans, { answer, ...identifiers }) => {

package/lib/exercises/math/probaStat/randomVariable/findValueForFairRandomVariable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findValueForFairRandomVariable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/findValueForFairRandomVariable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,SAAS,EAAE,eAAe,EAAE,CAAC;CAC9B,CAAC;AA0HF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAmBhE,CAAC"}
+{"version":3,"file":"findValueForFairRandomVariable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/findValueForFairRandomVariable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,SAAS,EAAE,eAAe,EAAE,CAAC;CAC9B,CAAC;AAgJF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAmBhE,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/findValueForFairRandomVariable.js

@@ -8,7 +8,6 @@ import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
-import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 import { mdTable } from "../../../../utils/markdown/mdTable.js";
 const getPropositions = (n, { answer }) => {
@@ -72,9 +71,30 @@ const isAnswerValid = (ans, { answer }) => {
         return handleVEAError(err);
     }
 };
+const _generateZeroMeanByLastValue = (n, valueRange = 10, minProb = 0) => {
+    // 1) probabilités positives puis normalisation
+    const raw = Array.from({ length: n }, () => round(Math.random(), 3));
+    const sumRaw = raw.reduce((a, b) => a + b, 0);
+    // on injecte un plancher minProb si demandé (simple et robuste)
+    // p_i = minProb + (1 - n*minProb) * raw_i/sumRaw
+    const scale = 1 - n * minProb;
+    const probs = raw.map((r) => round(minProb + scale * (r / sumRaw), 3));
+    // 2) tirer n-1 valeurs
+    const values = [];
+    for (let i = 0; i < n - 1; i++) {
+        values.push(round((Math.random() * 2 - 1) * valueRange, 3));
+    }
+    // 3) calculer la dernière valeur pour forcer Σ p_i v_i = 0
+    let partial = 0;
+    for (let i = 0; i < n - 1; i++)
+        partial += probs[i] * values[i];
+    const lastValue = -partial / probs[n - 1];
+    values.push(lastValue);
+    return values.map((v, i) => ({ value: v.toTree(), prob: probs[i].toTree() }));
+};
 const getFindProbaForFairGameQuestion = () => {
     const xValues = [
-        0,
+        randint(-10, 0),
         randint(1, 5),
         randint(5, 10),
         5 * randint(10, 20),
@@ -88,18 +108,9 @@ const getFindProbaForFairGameQuestion = () => {
     ];
     const left = round(1 - probas.reduce((acc, curr) => acc + curr, 0), 4);
     probas.unshift(left);
-    const xNodes = xValues.map((e) => e.toTree());
-    const yNodes = probas.map((e) => e.toTree());
-    const isXMissing = coinFlip();
-    if (isXMissing) {
-        xNodes[randint(0, xValues.length)] = "x".toTree();
-    }
-    else {
-        yNodes[randint(0, xValues.length)] = "x".toTree();
-    }
     const identifiers = {
-        valuesIds: xNodes.map((e) => e.toIdentifiers()),
-        probasIds: yNodes.map((e) => e.toIdentifiers()),
+        valuesIds: xValues.map((e) => e.toTree().toIdentifiers()),
+        probasIds: probas.map((e) => e.toTree().toIdentifiers()),
     };
     return getQuestionFromIdentifiers(identifiers);
 };
@@ -124,7 +135,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 export const findValueForFairRandomVariable = {
     id: "findValueForFairRandomVariable",
     connector: "=",
-    label: "Compléter la loi de probabilité d'une variable aléatoire pour rendre un jeu équitable",
+    label: "Compléter la loi de probabilité d'une variable aléatoire pour rendre un jeu équitable (espérance nulle)",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getFindProbaForFairGameQuestion(opts), nb),
     qcmTimer: 60,

package/lib/exercises/math/probaStat/randomVariable/randomVariableValues.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=randomVariableValues.d.ts.map

package/lib/exercises/math/probaStat/randomVariable/randomVariableValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableValues.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/randomVariableValues.ts"],"names":[],"mappings":""}

package/lib/exercises/math/probaStat/randomVariable/randomVariableValues.js

@@ -0,0 +1,83 @@
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   Question,
+//   QuestionGenerator,
+//   VEA,
+//   addValidProp,
+//   shuffleProps,
+//   GetAnswer,
+//   GetHint,
+//   GetCorrection,
+//   GetInstruction,
+//   GetKeys,
+//   GetQuestionFromIdentifiers,
+//   propWhile,
+// } from "../../../../exercises/exercise.js";
+// import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+// import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+export {};
+// type Identifiers = {};
+// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer);
+//   propWhile(propositions, n, () => {
+//     throw Error("QCM not implemented");
+//   });
+//   return shuffleProps(propositions, n);
+// };
+// const getAnswer: GetAnswer<Identifiers> = (identifiers) => {};
+// const getInstruction: GetInstruction<Identifiers> = (identifiers) => {
+//   return `Une urne contient $b$ boules blanches, $r$ boules rouges et $n$ boules noires. On tire au hasard une boule de l'urne. Chaque couleur donne un gain algébrique donné (aléatoire). La variable aléatoire X associe à chaque tirage le gain algébrique du joueur. `;
+// };
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+// const getKeys: GetKeys<Identifiers> = (identifiers) => {
+//   return [];
+// };
+// const isAnswerValid: VEA<Identifiers> = (ans, { answer }) => {
+//   try {
+//     throw Error("VEA not implemented");
+//   } catch (err) {
+//     return handleVEAError(err);
+//   }
+// };
+// const getRandomVariableValuesQuestion: QuestionGenerator<Identifiers> = (
+//   ops,
+// ) => {
+//   const identifiers: Identifiers = {};
+//   return getQuestionFromIdentifiers(identifiers);
+// };
+// const getQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers> = (
+//   identifiers,
+// ) => {
+//   return {
+//     answer: getAnswer(identifiers),
+//     instruction: getInstruction(identifiers),
+//     keys: getKeys(identifiers),
+//     answerFormat: "tex",
+//     identifiers,
+//     hint: getHint(identifiers),
+//     correction: getCorrection(identifiers),
+//   };
+// };
+// export const randomVariableValues: Exercise<Identifiers> = {
+//   id: "randomVariableValues",
+//   connector: "",
+//   label: undefined,
+//   isSingleStep: true,
+//   generator: (nb, opts) =>
+//     getDistinctQuestions(() => getRandomVariableValuesQuestion(opts), nb),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   getPropositions,
+//   isAnswerValid,
+//   subject: "Mathématiques",
+//   getInstruction,
+//   getHint,
+//   getCorrection,
+//   getAnswer,
+//   getQuestionFromIdentifiers,
+//   hasHintAndCorrection: true,
+// };

package/lib/exercises/math/probaStat/randomVariable/utils/randomVariableSituations.d.ts

@@ -0,0 +1,12 @@
+export declare const situations: ({
+    id: string;
+    label: string;
+    xis: never[];
+    pis: never[];
+} | {
+    label: string;
+    id?: undefined;
+    xis?: undefined;
+    pis?: undefined;
+})[];
+//# sourceMappingURL=randomVariableSituations.d.ts.map

package/lib/exercises/math/probaStat/randomVariable/utils/randomVariableSituations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableSituations.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/randomVariable/utils/randomVariableSituations.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;;;;;;;;IAqCtB,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js

@@ -0,0 +1,30 @@
+export const situations = [
+    {
+        id: "",
+        //params b,r,n ; gb,gr,gn
+        label: "Une urne contient $b$ boules blanches, $r$ boules rouges et $n$ boules noires. On tire au hasard une boule de l'urne. Chaque couleur donne un gain algébrique donné (aléatoire). La variable aléatoire X associe à chaque tirage le gain algébrique du joueur. ",
+        xis: [],
+        pis: [],
+    },
+    {
+        //param nbFaces; g_2, g_3, g_4, g_5, g_6
+        label: "On lance un dé équilibré à 12 faces (ou 4 ou 6 ou 20. Paramétrable ?). On gagne g_2€ pour chaque multiple de 2, g_3€ pour chaque multiples de 3 ... g_6€ pour chaque multiple de 6. Les gains sont cumulables. X donne le gain total du joueur.",
+    },
+    {
+        //param b;r , gb;gr
+        label: "Une urne contient b boules rouges blanches et r boules rouges. On tire deux boules successivement et avec remise (ou sans remise : paramétrable). Une boule rouge rapporte x points, une boule noire en fait perdre y. La varialbe aléatoire X associe à chaque tirage le est le gain algébrique du joueur.",
+    },
+    {
+        //param n; gp,gf
+        label: "On lance n fois d'affilée une pièce de monnaie (n entre 1 et 4). Chaque pile rapporte a points et chaque face fait perdre b points. La variable aléatoire X associe à chaque tirage le gain algébrique du joueur.",
+    },
+    {
+        label: "On lance deux dès équilibrés à 6 faces (ou 4, ou 12, ou 20) et on fait la somme des points. La variable aléatoire X associe à chaque tirage le gain algébrique du joueur.",
+    },
+    {
+        label: "On lance deux dès équilibrés à 6 faces (ou 4, ou 12, ou 20) et on fait la différence des points. La variable aléatoire X associe à chaque tirage le gain algébrique du joueur.",
+    },
+    {
+        label: "On lance deux dès équilibrés à 6 faces (ou 4, ou 12, ou 20) et on fait la CL... des points. La variable aléatoire X associe à chaque tirage le gain algébrique du joueur.",
+    },
+];

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"headsOrTailsTwiceOutcomes.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAS9B,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA6NF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}
+{"version":3,"file":"headsOrTailsTwiceOutcomes.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAS9B,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA8NF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.js

@@ -124,7 +124,7 @@ const getPropositions = (n, { answer }) => {
         [0, 1],
         [0, 1],
     ]);
-    const arrStr = arrOutcome.map(([v1, v2]) => `(${arrStrOutcomeSmall[v1]};${arrStrOutcomeSmall[v2]})`);
+    const arrStr = arrOutcome.map(([v1, v2]) => `\\left(${arrStrOutcomeSmall[v1]};${arrStrOutcomeSmall[v2]}\\right)`);
     arrStr.forEach((str) => {
         tryToAddWrongProp(propositions, str);
     });

package/lib/exercises/math/sequences/geometric/geometricReasonUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricReasonUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricReasonUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA0GF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAYtD,CAAC"}
+{"version":3,"file":"geometricReasonUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricReasonUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA2JF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}

package/lib/exercises/math/sequences/geometric/geometricReasonUsage.js

@@ -1,6 +1,7 @@
 import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { power } from "../../../../tree/nodes/operators/powerNode.js";
@@ -25,6 +26,37 @@ const getStartStatement = (identifiers) => {
     const { askedRank } = identifiers;
     return `u_{${askedRank}}`;
 };
+const getHint = () => {
+    return `Puisque $u$ est une suite géométrique, alors pour passer d'un terme au suivant, on doit multiplier par la raison $q$.`;
+};
+const getCorrection = (identifiers) => {
+    const { reason, startValue, startRank, askedRank } = identifiers;
+    const un1 = round(startValue * reason, 4);
+    const un2 = round(un1 * reason, 4);
+    const un3 = round(un2 * reason, 4);
+    return `Puisque $u$ est une suite géométrique, alors pour passer d'un terme au suivant, on doit multiplier par la raison $q$.
+    
+On a donc : 
+
+$$
+u_{${startRank + 1}} = ${multiply(`u_{${startRank}}`, reason).toTex()} = ${un1.frenchify()}
+$$
+
+${askedRank > startRank + 1
+        ? `
+$$
+u_{${startRank + 2}} = ${multiply(`u_{${startRank + 1}}`, reason).toTex()} = ${un2.frenchify()}
+$$`
+        : ""}
+
+${askedRank > startRank + 2
+        ? `
+$$
+u_{${startRank + 1}} = ${multiply(`u_{${startRank}}`, reason).toTex()} = ${un3.frenchify()}
+$$`
+        : ""}
+`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
@@ -33,6 +65,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["u", "underscore", "equal"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -90,4 +124,5 @@ export const geometricReasonUsage = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sequences/index.js

@@ -7,3 +7,4 @@ export * from "./sequenceEvaluation.js";
 export * from "./sequencePlot.js";
 export * from "./graph/index.js";
 export * from "./notation/index.js";
+// export * from "./limits/index.js";

package/lib/exercises/math/sequences/limits/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./sequenceLimitReading.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/limits/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/limits/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/lib/exercises/math/sequences/limits/index.js

@@ -0,0 +1 @@
+export * from "./sequenceLimitReading.js";

package/lib/exercises/math/sequences/limits/sequenceLimitReading.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sequenceLimitReading.d.ts.map

package/lib/exercises/math/sequences/limits/sequenceLimitReading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequenceLimitReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/limits/sequenceLimitReading.ts"],"names":[],"mappings":""}

package/lib/exercises/math/sequences/limits/sequenceLimitReading.js

@@ -0,0 +1,163 @@
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   QuestionGenerator,
+//   VEA,
+//   addValidProp,
+//   shuffleProps,
+//   GetAnswer,
+//   GetHint,
+//   GetCorrection,
+//   GetInstruction,
+//   GetKeys,
+//   GetGGBOptions,
+//   GetQuestionFromIdentifiers,
+//   propWhile,
+//   tryToAddWrongProp,
+// } from "../../../../exercises/exercise.js";
+// import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+// import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+// import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+// import { Point } from "../../../../math/geometry/point.js";
+// import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+// import { randint } from "../../../../math/utils/random/randint.js";
+// import {
+//   NodeIdentifiers,
+//   reifyAlgebraic,
+// } from "../../../../tree/nodes/nodeConstructor.js";
+// import { add } from "../../../../tree/nodes/operators/addNode.js";
+// import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+// import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+export {};
+// type Identifiers = {
+//   formula: NodeIdentifiers;
+//   type: number;
+// };
+// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer);
+//   tryToAddWrongProp(propositions, "\\text{Aucun}");
+//   propWhile(propositions, n, () => {
+//     throw Error("QCM not implemented");
+//   });
+//   return shuffleProps(propositions, n);
+// };
+// const getAnswer: GetAnswer<Identifiers> = (identifiers) => {
+//   const { formula, type } = identifiers;
+//   const u = reifyAlgebraic(formula);
+//   switch (type) {
+//     case 0:
+//     default: {
+//       const value = u.toDetailedEvaluation({ n: (100).toTree() }).evaluate();
+//       if (value > 0) return "+\\infty";
+//       return "-\\infty";
+//     }
+//   }
+// };
+// const getInstruction: GetInstruction<Identifiers> = () => {
+//   return `Ci-dessous est tracé le nuage de points représentant une suite $u$.
+// Quelle semble être la limite de la suite $u$ quand $n$ tend vers $+\\infty$ ? Si elle n'en a pas, on écrira "Aucun".`;
+// };
+// const getHint: GetHint<Identifiers> = () => {
+//   return `Observe les termes de la suite lorsque $n$ devient très grand. Si ces termes semblent se rapprocher d'une certaine valeur, alors on peut conjecturer que cette valeur est la limite de la suite. Cette valeur peut être $+\\infty$ ou $-\\infty$.`;
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   return ``;
+// };
+// const getGGBOptions: GetGGBOptions<Identifiers> = (identifiers) => {
+//   const { formula } = identifiers;
+//   const u = reifyAlgebraic(formula);
+//   const values = Array.from({ length: 50 }).map((_, index) => {
+//     return u.toDetailedEvaluation({ n: index.toTree() }).evaluate();
+//   });
+//   const points = values.map((v, i) => new Point(`A_{${i}}`, i, v));
+//   const ggb = new GeogebraConstructor({
+//     commands: points.flatMap((e) =>
+//       e.toGGBCommand({
+//         showLabel: false,
+//         size: 3,
+//       }),
+//     ),
+//     lockedAxesRatio: false,
+//   });
+//   const yMin = Math.min(-1, Math.min(...values.slice(0, 10))) - 2;
+//   const yMax = Math.max(1, Math.max(...values.slice(0, 10))) + 2;
+//   return ggb.getOptions({
+//     coords: [-1, 10, yMin, yMax],
+//   });
+// };
+// const getKeys: GetKeys<Identifiers> = () => {
+//   return ["aucun"];
+// };
+// const isAnswerValid: VEA<Identifiers> = (ans, { answer }) => {
+//   try {
+//     if (answer.includes("\\infty")) return ans === answer;
+//     return numberVEA(ans, answer, undefined, 0.3);
+//   } catch (err) {
+//     return handleVEAError(err);
+//   }
+// };
+// const getSequenceLimitReadingQuestion: QuestionGenerator<Identifiers> = () => {
+//   const type = randint(10);
+//   let formula: NodeIdentifiers;
+//   switch (type) {
+//     case 0:
+//       formula = AffineConstructor.random(undefined, undefined, "n")
+//         .toTree()
+//         .toIdentifiers();
+//       break;
+//     case 1:
+//     default:
+//       {
+//         const k = randint(-10, 10);
+//         formula = add(frac(1, add("n", 1)), k).toIdentifiers();
+//       }
+//       break;
+//   }
+//   const identifiers: Identifiers = {
+//     formula,
+//     type,
+//   };
+//   //0: affine
+//   //1: 1/n+k
+//   //2: an+b/cn+d
+//   //3: exp
+//   //4:
+//   //styles:
+//   //exp, lineaire, alternée, exp décroissant, anarchique
+//   return getQuestionFromIdentifiers(identifiers);
+// };
+// const getQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers> = (
+//   identifiers,
+// ) => {
+//   return {
+//     answer: getAnswer(identifiers),
+//     instruction: getInstruction(identifiers),
+//     keys: getKeys(identifiers),
+//     answerFormat: "tex",
+//     identifiers,
+//     hint: getHint(identifiers),
+//     correction: getCorrection(identifiers),
+//     ggbOptions: getGGBOptions(identifiers),
+//   };
+// };
+// export const sequenceLimitReading: Exercise<Identifiers> = {
+//   id: "sequenceLimitReading",
+//   label: "Conjecturer graphiquement la limite d'une suite",
+//   isSingleStep: true,
+//   generator: (nb, opts) =>
+//     getDistinctQuestions(() => getSequenceLimitReadingQuestion(opts), nb),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   getPropositions,
+//   isAnswerValid,
+//   subject: "Mathématiques",
+//   getHint,
+//   getCorrection,
+//   getInstruction,
+//   getAnswer,
+//   getGGBOptions,
+//   hasGeogebra: true,
+//   getQuestionFromIdentifiers,
+// };

package/lib/exercises/math/trigonometry/circle/areReelsOnTheSameTrigoCirclePoint.js

@@ -12,7 +12,7 @@ import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../utils/alea/random.js";
 const getPropositions = (n, { answer }) => {
     const propositions = [];
-    addValidProp(propositions, answer);
+    addValidProp(propositions, answer, "raw");
     tryToAddWrongProp(propositions, "Oui", "raw");
     tryToAddWrongProp(propositions, "Non", "raw");
     tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
@@ -82,7 +82,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: [],
-        answerFormat: "tex",
+        answerFormat: "raw",
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),

package/lib/exercises/vea/numberVEA.d.ts

@@ -1,2 +1,2 @@
-export declare const numberVEA: (studentAns: string, answer: string, roundTo?: number) => boolean;
+export declare const numberVEA: (studentAns: string, answer: string, roundTo?: number, margin?: number) => boolean;
 //# sourceMappingURL=numberVEA.d.ts.map

package/lib/exercises/vea/numberVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numberVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/numberVEA.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,GACpB,YAAY,MAAM,EAClB,QAAQ,MAAM,EACd,UAAU,MAAM,YAKjB,CAAC"}
+{"version":3,"file":"numberVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/numberVEA.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,GACpB,YAAY,MAAM,EAClB,QAAQ,MAAM,EACd,UAAU,MAAM,EAChB,SAAS,MAAM,YAShB,CAAC"}

package/lib/exercises/vea/numberVEA.js

@@ -1,7 +1,12 @@
 import { numberParser } from "../../tree/parsers/numberParser.js";
-export const numberVEA = (studentAns, answer, roundTo) => {
+export const numberVEA = (studentAns, answer, roundTo, margin) => {
     const parsed = numberParser(studentAns, roundTo);
     if (!parsed)
         return false;
-    return parsed === answer;
+    if (margin === undefined) {
+        return parsed === answer;
+    }
+    else {
+        return Math.abs(parsed.unfrenchify() - answer.unfrenchify()) < margin;
+    }
 };

package/lib/exercises/vea/signLineVEA.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param ans ligne des signes du student
+ * @param answerTable ligne des signes de la réponse
+ * cette fonction ne check que la ligne des signes
+ */
+export declare const signLineVEA: (ans: string[], answerTable: string[]) => boolean;
+//# sourceMappingURL=signLineVEA.d.ts.map

package/lib/exercises/vea/signLineVEA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signLineVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/signLineVEA.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,EAAE,aAAa,MAAM,EAAE,YAE/D,CAAC"}

package/lib/exercises/vea/signLineVEA.js

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param ans ligne des signes du student
+ * @param answerTable ligne des signes de la réponse
+ * cette fonction ne check que la ligne des signes
+ */
+export const signLineVEA = (ans, answerTable) => {
+    return ans.slice(1).every((cell, i) => cell === answerTable[i + 1]);
+};

package/lib/exercises/vea/signTableVEA.d.ts

@@ -0,0 +1,2 @@
+export declare const signTableVEA: (ans: string[][], answerTable: string[][]) => boolean;
+//# sourceMappingURL=signTableVEA.d.ts.map

package/lib/exercises/vea/signTableVEA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signTableVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/signTableVEA.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,EAAE,EAAE,EAAE,aAAa,MAAM,EAAE,EAAE,YAIpE,CAAC"}

package/lib/exercises/vea/signTableVEA.js

@@ -0,0 +1,5 @@
+import { signLineVEA } from "./signLineVEA.js";
+import { xTableLineVEA } from "./xTableLineVEA.js";
+export const signTableVEA = (ans, answerTable) => {
+    return (xTableLineVEA(ans[0], answerTable[0]) && signLineVEA(ans[1], answerTable[1]));
+};

package/lib/exercises/vea/varLineVEA.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param ans lignes des variations du student
+ * @param answerTable lignes de variations de la réponse
+ * cette fonction ne check que la ligne des variations
+ */
+export declare const varLineVEA: (ans: string[][], answerTable: string[][]) => boolean;
+//# sourceMappingURL=varLineVEA.d.ts.map