math-exercises 3.0.132 → 3.0.134

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormulaFirstRankOne.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    reason: number;
+    firstValue: number;
+};
+export declare const geometricFindExplicitFormulaFirstRankOne: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=geometricFindExplicitFormulaFirstRankOne.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindExplicitFormulaFirstRankOne.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormulaFirstRankOne.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAoIF,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAAC,WAAW,CAe1E,CAAC"}

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

@@ -0,0 +1,112 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { PowerNode } from "../../../../tree/nodes/operators/powerNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { parseLatex } from "../../../../tree/parsers/latexParser.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+const getInstruction = (identifiers) => {
+    const { firstValue, reason } = identifiers;
+    const firstRank = 1;
+    return `$(u_n)$ est une suite géométrique de premier terme $u_{${firstRank}} = ${firstValue}$ et de raison $q = ${reason}$. 
+  
+Donner l'expression de $u_n$ en fonction de $n$.`;
+};
+const getAnswer = (identifiers) => {
+    const { firstValue, reason } = identifiers;
+    const formula = new MultiplyNode(new NumberNode(firstValue), new PowerNode(new NumberNode(reason), substract("n", 1)));
+    const answer = "u_n=" + formula.toTex();
+    return answer;
+};
+const getHint = () => {
+    return `Utilise la formule générale d'une suite géométrique : 
+    
+$$
+u_n = u_1 \\times r^{n-1}
+$$
+
+où $u_1$ est le premier terme et $r$ la raison.`;
+};
+const getCorrection = (identifiers) => {
+    const { firstValue, reason } = identifiers;
+    const answer = getAnswer(identifiers);
+    return `La formule générale d'une suite géométrique est :
+    
+$$
+u_n = u_1 \\times r^{n-1}
+$$
+
+où $u_1$ est le premier terme et $r$ la raison.
+    
+Ici, puisque $u_1 = ${firstValue}$ et $r = ${reason}$, on a : 
+
+$$
+${answer}
+$$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["un", "equal", "n"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getGeometricFindExplicitFormula = () => {
+    const firstValue = randint(1, 10);
+    const reason = randint(2, 10);
+    const identifiers = { reason, firstValue };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, reason, firstValue }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "u_n=" +
+        new MultiplyNode(new NumberNode(firstValue), new PowerNode(new NumberNode(reason), new VariableNode("n"))).toTex());
+    tryToAddWrongProp(propositions, "u_n=" +
+        new MultiplyNode(new NumberNode(reason), new PowerNode(new NumberNode(firstValue), substract("n", 1))).toTex());
+    propWhile(propositions, n, () => {
+        const wrongAnswer = new MultiplyNode(new NumberNode(firstValue + randint(-firstValue, 2 * firstValue + 1)), new PowerNode(new NumberNode(reason + +randint(-reason + 1, 2 * reason + 1)), substract("n", 1)));
+        tryToAddWrongProp(propositions, "u_n=" + wrongAnswer.toTex());
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { reason, firstValue }) => {
+    const formula = new MultiplyNode(new NumberNode(firstValue), new PowerNode(new NumberNode(reason), substract("n", 1)));
+    const equal = new EqualNode(new VariableNode("u_n"), formula, {
+        allowRawRightChildAsSolution: true,
+    });
+    const texs = equal.toAllValidTexs();
+    return (texs.includes(ans) ||
+        (() => {
+            const splitted = ans.split("=");
+            const rightTerm = splitted[1] ?? splitted[0];
+            const nodeAns = parseLatex(rightTerm);
+            const differenceNode = substract(nodeAns, formula);
+            return (differenceNode.evaluate({ n: 0 }) === 0 &&
+                differenceNode.evaluate({ n: 1 }) === 0 &&
+                differenceNode.evaluate({ n: 5 }) === 0);
+        })());
+};
+export const geometricFindExplicitFormulaFirstRankOne = {
+    id: "geometricFindExplicitFormulaFirstRankOne",
+    connector: "=",
+    label: "Déterminer la formule générale d'une suite géométrique (premier rang $u_1$)",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getGeometricFindExplicitFormula, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/sequences/geometric/geometricFindTermFirstRankOne.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindTermFirstRankOne.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindTermFirstRankOne.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAiGF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAe/D,CAAC"}

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

@@ -0,0 +1,97 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.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 { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { firstTerm, reason, askedRank } = identifiers;
+    return `Soit $u$ la suite géométrique de premier terme $u_1 = ${firstTerm}$ et de raison $q = ${reason}$. Calculer $u_{${askedRank}}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { firstTerm, reason, askedRank } = identifiers;
+    const answer = firstTerm * Math.pow(reason, askedRank - 1);
+    return answer.frenchify();
+};
+const getHint = () => {
+    return `Le terme général d'une suite geométrique est : 
+    
+$$
+u_n = u_1 \\times q^{n-1}
+$$
+
+où $u_1$ est le premier terme et $q$ la raison.`;
+};
+const getCorrection = (identifiers) => {
+    const { firstTerm, reason, askedRank } = identifiers;
+    return `Le terme général de la suite $u$ est : 
+
+${alignTex([
+        [`u_n`, "=", `u_1 \\times q^{n-1}`],
+        [
+            "",
+            "=",
+            new MultiplyNode(firstTerm.toTree(), new PowerNode(reason.toTree(), new SubstractNode(new VariableNode("n"), (1).toTree()))).toTex(),
+        ],
+    ])}    
+
+Il suffit alors de remplacer $n$ par $${askedRank}$ dans la formule : 
+
+${alignTex([
+        [
+            `u_{${askedRank}}`,
+            "=",
+            `${new MultiplyNode(firstTerm.toTree(), new PowerNode(reason.toTree(), (askedRank - 1).toTree())).toTex()}`,
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+    `;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        identifiers,
+    };
+    return question;
+};
+const getGeometricFindTermQuestion = () => {
+    const firstRank = 1;
+    const firstTerm = randint(-10, 10, [0]);
+    const reason = randint(2, 6);
+    const askedRank = randint(5, 12);
+    const identifiers = { firstRank, askedRank, firstTerm, reason };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, askedRank, firstTerm, reason }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const fake = firstTerm * Math.pow(reason, askedRank - randint(-5, 3, [1]));
+        tryToAddWrongProp(propositions, fake + "");
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+export const geometricFindTermFirstRankOne = {
+    id: "geometricFindTermFirstRankOne",
+    connector: "=",
+    label: "Calculer un terme d'une suite géométrique à partir de son premier terme ($u_1$) et sa raison",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getGeometricFindTermQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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;AAwGF,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,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"}

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

@@ -9,7 +9,9 @@ import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
 const getInstruction = (identifiers) => {
     const { reason, startRank, startValue, askedRank } = identifiers;
-    return `$(u_n)$ est une suite géométrique de raison $q = ${reason}$ et on sait que $u_{${startRank}} = ${startValue}$. Calculer : $u_{${askedRank}}$`;
+    return `$(u_n)$ est une suite géométrique de raison $q = ${reason}$ et on sait que $u_{${startRank}} = ${startValue}$. 
+  
+Calculer le terme $u_{${askedRank}}$.`;
 };
 const getAnswer = (identifiers) => {
     const answer = getAnswerNode(identifiers).evaluate().frenchify();

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

@@ -1 +1 @@
-{"version":3,"file":"geometricRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAwEF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"geometricRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAgFF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}

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

@@ -5,7 +5,15 @@ import { shuffle } from "../../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers) => {
     const { firstRank, firstValue, reason } = identifiers;
     const askedRank = firstRank + 1;
-    return `$(u_n)$ est une suite définie par $u_{n+1} = ${reason}\\times u_n$ et $u_{${firstRank}} = ${firstValue}$. Calculer : $u_{${askedRank}}$`;
+    return `$(u_n)$ est une suite définie par :
+  
+$$
+u_{n+1} = ${reason}\\times u_n
+$$
+
+et $u_{${firstRank}} = ${firstValue}$. 
+
+Calculer le terme $u_{${askedRank}}$.`;
 };
 const getAnswer = (identifiers) => {
     const { firstValue, reason } = identifiers;

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

@@ -1,11 +1,13 @@
 export * from "./geometricExplicitFormulaUsage.js";
 export * from "./geometricFindExplicitFormula.js";
+export * from "./geometricFindExplicitFormulaFirstRankOne.js";
 export * from "./geometricFindReason.js";
 export * from "./geometricFirstTermsSum.js";
 export * from "./geometricReasonUsage.js";
 export * from "./geometricRecurrenceFormulaUsage.js";
 export * from "./geometricFindExplicitFormulaFirstTermRandom.js";
 export * from "./geometricFindTerm.js";
+export * from "./geometricFindTermFirstRankOne.js";
 export * from "./geometricRecognizeReasonFromFirstTerms.js";
 export * from "./geometricFirstTermsGeneralSum.js";
 export * from "./geometricVariations.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,mCAAmC,CAAC;AAClD,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,wBAAwB,CAAC;AACvC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,oCAAoC,CAAC;AACnD,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,wBAAwB,CAAC;AACvC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,oCAAoC,CAAC;AACnD,cAAc,0BAA0B,CAAC"}

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

@@ -1,11 +1,13 @@
 export * from "./geometricExplicitFormulaUsage.js";
 export * from "./geometricFindExplicitFormula.js";
+export * from "./geometricFindExplicitFormulaFirstRankOne.js";
 export * from "./geometricFindReason.js";
 export * from "./geometricFirstTermsSum.js";
 export * from "./geometricReasonUsage.js";
 export * from "./geometricRecurrenceFormulaUsage.js";
 export * from "./geometricFindExplicitFormulaFirstTermRandom.js";
 export * from "./geometricFindTerm.js";
+export * from "./geometricFindTermFirstRankOne.js";
 export * from "./geometricRecognizeReasonFromFirstTerms.js";
 export * from "./geometricFirstTermsGeneralSum.js";
 export * from "./geometricVariations.js";

package/lib/exercises/math/sequences/recurrenceFormulaUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/recurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAiEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAaxD,CAAC"}
+{"version":3,"file":"recurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/recurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAwEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAaxD,CAAC"}

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

@@ -5,9 +5,16 @@ import { randint } from "../../../math/utils/random/randint.js";
 const getInstruction = (identifiers) => {
     const { rank, u0, coeffs } = identifiers;
     const u = new Polynomial(coeffs, "u_n");
-    return `Soit $u$ la suite définie par $u_0 = ${u0}$ et pour tout $n\\geq 1$, $u_{n+1} = ${u
-        .toTree()
-        .toTex()}$. Calculer $u_${rank}$.`;
+    return `Soit $u$ la suite définie par : 
+  
+- $u_0 = ${u0}$,
+
+- pour tout $n\\geq 1$ :
+$$
+u_{n+1} = ${u.toTree().toTex()}
+$$
+
+Calculer $u_${rank}$.`;
 };
 const getAnswer = (identifiers) => {
     const { rank, u0, coeffs } = identifiers;

package/lib/exercises/pc/index.d.ts

@@ -28,6 +28,5 @@ export * from "./motion/index.js";
 export * from "./dosage/index.js";
 export * from "./spectral/index.js";
 export * from "./power/index.js";
-export * from "./optics/index.js";
 export * from "./mathExosInPC.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/pc/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,eAAe,CAAC;AAC9B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,SAAS,CAAC;AACxB,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mCAAmC,CAAC;AAClD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,uBAAuB,CAAC;AAEtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,iBAAiB,CAAC;AAChC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,eAAe,CAAC;AAC9B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,SAAS,CAAC;AACxB,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mCAAmC,CAAC;AAClD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,uBAAuB,CAAC;AAEtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,iBAAiB,CAAC;AAChC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC"}

package/lib/exercises/pc/index.js

@@ -28,5 +28,4 @@ export * from "./motion/index.js";
 export * from "./dosage/index.js";
 export * from "./spectral/index.js";
 export * from "./power/index.js";
-export * from "./optics/index.js";
 export * from "./mathExosInPC.js";

package/lib/exercises/pc/motion/averageSpeed.d.ts

@@ -6,10 +6,8 @@ type Msr = {
 type Identifiers = {
     distance: Msr;
     time: Msr;
-    opts: Options;
 };
 type Options = {
-    acceptedInputType: string;
     unitTex: string;
 };
 export declare const averageSpeed: Exercise<Identifiers, Options>;

package/lib/exercises/pc/motion/averageSpeed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"averageSpeed.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/averageSpeed.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,GAAG,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhD,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,GAAG,CAAC;IACd,IAAI,EAAE,GAAG,CAAC;IACV,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AA8NF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAsBF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAcvD,CAAC"}
+{"version":3,"file":"averageSpeed.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/averageSpeed.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,GAAG,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhD,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,GAAG,CAAC;IACd,IAAI,EAAE,GAAG,CAAC;CACX,CAAC;AAkOF,KAAK,OAAO,GAAG;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAqBF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAcvD,CAAC"}

package/lib/exercises/pc/motion/averageSpeed.js

@@ -11,20 +11,23 @@ import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
 import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 const timeUnits = [TimeUnit.h, TimeUnit.min];
 const distanceUnitValues = [DistanceUnit.km, DistanceUnit.m];
-const getAcceptedInputTypesSentence = (identifiers) => {
-    const { opts } = identifiers;
+const getAcceptedInputTypesSentence = (acceptedInputType) => {
     return `Donner le résultat
 ${(() => {
-        switch (opts.acceptedInputType) {
+        switch (acceptedInputType) {
             case "exact":
                 return "sous forme exacte";
-            case "significant(3)":
+            default:
+            case "arrondi avec 3 chiffres significatifs":
                 return "approché avec $3$ chiffres significatifs";
         }
     })()}.`;
 };
-const getInstruction = (identifiers) => {
-    const { distance, time, opts } = identifiers;
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const acceptedInputType = "arrondi avec 3 chiffres significatifs";
+    const { distance, time } = identifiers;
+    const { unitTex } = opts;
     const distanceMeasure = new Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]);
     const timeMeasure = new Measure(time.value, 0, timeUnits[time.unitIndex]);
     const instruction = `Soit un objet parcourant $${distanceMeasure.toTex({
@@ -32,13 +35,14 @@ const getInstruction = (identifiers) => {
     })}$ en $${timeMeasure.toTex({ notScientific: true })}$.
 
 
-Calculer la vitesse moyenne de cet objet en ${opts.unitTex}.
+Calculer la vitesse moyenne de cet objet en ${unitTex}.
 
-${getAcceptedInputTypesSentence(identifiers)}
+${getAcceptedInputTypesSentence(acceptedInputType)}
   `;
     return instruction;
 };
-const getHint = ({ opts }) => {
+const getHint = (_, optsIn) => {
+    const opts = optsIn ?? optsDefault;
     const unlatexUnit = opts.unitTex.substring(1, opts.unitTex.length - 1);
     return `La vitesse moyenne est donnée par : 
   
@@ -46,8 +50,9 @@ $$
 \\frac{\\text{distance}}{\\text{temps}} \\ ${unlatexUnit}
 $$`;
 };
-const getCorrection = (identifiers) => {
-    const { distance, time, opts } = identifiers;
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { distance, time } = identifiers;
     let correction = ``;
     const distanceMeasure = new Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]).convert("m");
     const timeMeasure = new Measure(time.value, 0, timeUnits[time.unitIndex]).convert("s");
@@ -105,7 +110,8 @@ const isAnswerValid = (ans, { answer, ...identifiers }) => {
     const answerNode = parseAlgebraic(getAnswerMeasure(identifiers).toTex({ hideUnit: true }));
     return substract(ansNode, answerNode).simplify().evaluate() === 0;
 };
-const getPropositions = (n, { answer, distance, time, opts }) => {
+const getPropositions = (n, { answer, distance, time }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
     const propositions = [];
     const unlatexUnit = opts.unitTex.substring(1, opts.unitTex.length - 1);
     addValidProp(propositions, `${answer} \\ ${unlatexUnit}`);
@@ -138,41 +144,27 @@ const generatePropositions = (distance, time) => {
         distance.divide(time).toSignificant(2).toTex({ hideUnit: true }),
     ];
 };
-const getKeys = () => {
-    return [];
-    // return [`\\text{m} \\cdot \\text{s}^{-1}`].map((tex) => {
-    //   return {
-    //     id: "custom",
-    //     label: tex,
-    //     labelType: "raw",
-    //     mathfieldInstructions: {
-    //       method: "write",
-    //       content: tex,
-    //     },
-    //   } as KeyProps;
-    // });
-};
 const getAverageSpeedQuestion = (optsIn) => {
-    const opts = Object.assign(optsDefault, optsIn) ?? optsDefault;
+    const opts = optsIn ?? optsDefault;
     const distance = { value: randint(70, 151), unitIndex: randint(0, 2) };
     const time = { value: randint(10, 61), unitIndex: randint(0, 2) };
-    const identifiers = { distance, time, opts };
-    return getQuestionFromIdentifiers(identifiers);
+    const identifiers = { distance, time };
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
-        keys: getKeys(identifiers),
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
         answerFormat: "tex",
         identifiers,
+        options: opts,
     };
     return question;
 };
 const optsDefault = {
-    acceptedInputType: "significant(3)",
     unitTex: "$\\text{m} \\cdot \\text{s}^{-1}$",
 };
 const options = [

package/lib/exercises/pc/weight/calculateWeight.d.ts

@@ -1,7 +1,6 @@
 import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
     mass: number;
-    optsIdent: Options;
 };
 type InputType = "decimal" | "sci";
 type Options = {

package/lib/exercises/pc/weight/calculateWeight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateWeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/calculateWeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,KAAK,SAAS,GAAG,SAAS,GAAG,KAAK,CAAC;AAEnC,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAuMF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAc1D,CAAC"}
+{"version":3,"file":"calculateWeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/calculateWeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,KAAK,SAAS,GAAG,SAAS,GAAG,KAAK,CAAC;AAEnC,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAkNF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAc1D,CAAC"}

package/lib/exercises/pc/weight/calculateWeight.js

@@ -28,8 +28,9 @@ const options = [
         defaultValue: [optsDefault.nbDigits],
     },
 ];
-const getInstruction = (identifiers) => {
-    const { mass, optsIdent } = identifiers;
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { mass } = identifiers;
     const instruction = `Soit un objet avec une masse de $${mass}\\ \\textrm{kg}$.
 
 L'accélération due à la gravité vaut $${g.frenchify()}$ $\\textrm{m} \\cdot \\textrm{s}^{${-2}}$. 
@@ -37,7 +38,7 @@ L'accélération due à la gravité vaut $${g.frenchify()}$ $\\textrm{m} \\cdot
 Calculer le poids de cet objet en Newtons.
 Donner le résultat 
 ${(() => {
-        switch (optsIdent.inputType) {
+        switch (opts.inputType) {
             case "decimal":
                 return `en écriture décimale`;
             case "sci":
@@ -45,7 +46,7 @@ ${(() => {
         }
     })()}
 ${(() => {
-        switch (optsIdent.nbDigits) {
+        switch (opts.nbDigits) {
             case "0":
                 return `arrondie à l'unité`;
             case "1":
@@ -77,25 +78,30 @@ const getCorrection = (identifiers) => {
     const correction = `Pour calculer le poids de l'objet, on utilise la formule : 
   
 $$
-P=m \\cdot g
+P = m \\cdot g
 $$
 
 On a : 
 
 $$
-P = ${mass.frenchify()} \\times ${g.frenchify()} \\Rightarrow P=${answer}
+P = ${mass.frenchify()} \\times ${g.frenchify()}
+$$
+
+$$
+P \\approx ${answer}
 $$`;
     return correction;
 };
-const getAnswer = (identifiers) => {
-    const { mass, optsIdent } = identifiers;
-    switch (optsIdent.inputType) {
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { mass } = identifiers;
+    switch (opts.inputType) {
         case "decimal": {
-            const answer = round(mass * g, Number(optsIdent.nbDigits));
+            const answer = round(mass * g, Number(opts.nbDigits));
             return `${answer.frenchify()}N`;
         }
         case "sci": {
-            const answer = (mass * g).toScientific(Number(optsIdent.nbDigits));
+            const answer = (mass * g).toScientific(Number(opts.nbDigits));
             return `${answer.toTex()}N`;
         }
     }
@@ -103,12 +109,13 @@ const getAnswer = (identifiers) => {
 const isAnswerValid = (ans, { answer }) => {
     return ans === answer;
 };
-const getPropositions = (n, { answer, mass, optsIdent }) => {
+const getPropositions = (n, { answer, mass }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
     const propositions = [];
     const weight = mass * g;
     addValidProp(propositions, answer);
-    const nbDigits = Number(optsIdent.nbDigits);
-    switch (optsIdent.inputType) {
+    const nbDigits = Number(opts.nbDigits);
+    switch (opts.inputType) {
         case "decimal":
             {
                 tryToAddWrongProp(propositions, `${round(weight * 10, nbDigits).frenchify()}N`);
@@ -142,16 +149,16 @@ const getCalculateWeightQuestion = (optsIn) => {
         })
         : optsDefault;
     const mass = randint(30, 151);
-    const identifiers = { mass: mass, optsIdent: opts };
+    const identifiers = { mass: mass };
     return getQuestionFromIdentifiers(identifiers, opts);
 };
 const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
         keys: ["N"],
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
         answerFormat: "tex",
         identifiers,
         options: opts,