math-exercises 3.0.69 → 3.0.71

package/lib/exercises/pc/waves/periodicWaveCelerity.js

@@ -4,6 +4,84 @@ import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { round, roundSignificant } from "../../../math/utils/round.js";
 import { random } from "../../../utils/alea/random.js";
 // v = lambda / T
+const getInstruction = (identifiers) => {
+    const { varAsked, v, l, T } = identifiers;
+    switch (varAsked) {
+        case "v":
+            return `Une onde périodique a une longueur d'onde de $${roundSignificant(l, 1)}\\ \\textrm{m}$ et une période de $${roundSignificant(T, 1)}\\ \\textrm{s}$. 
+      
+Quelle est sa célérité ?`;
+            break;
+        case "T":
+            return `Une onde périodique a une longueur d'onde de $${roundSignificant(l, 1)}\\ \\textrm{m}$ et une célérité de $${roundSignificant(v, 1)}\\ \\textrm{m}\\cdot\\textrm{s}^{-1}$. 
+      
+Quelle est sa période ?`;
+            break;
+        case "l":
+        default:
+            return `Une onde périodique a une période de $${roundSignificant(T, 1)}\\ \\textrm{m}$ et une célérité de $${roundSignificant(v, 1)}\\ \\textrm{m}\\cdot\\textrm{s}^{-1}$. 
+      
+Quelle est sa longueur d'onde ?`;
+            break;
+    }
+};
+const getAnswer = (identifiers) => {
+    const { varAsked, v, l, T } = identifiers;
+    switch (varAsked) {
+        case "v":
+            return roundSignificant(v, 1);
+            break;
+        case "T":
+            return roundSignificant(T, 1);
+            break;
+        case "l":
+        default:
+            return roundSignificant(l, 1);
+            break;
+    }
+};
+const getHint = (identifiers) => {
+    const { varAsked, v, l, T } = identifiers;
+    switch (varAsked) {
+        case "v":
+            return "Utilisez la formule de la célérité: $v = \\frac{\\lambda}{T}$";
+            break;
+        case "T":
+            return "Utilisez la formule de la période: $T = \\frac{\\lambda}{v}$";
+            break;
+        case "l":
+        default:
+            return "Utilisez la formule de la longueur d'onde: $\\lambda = v \\times T$";
+            break;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { varAsked, v, l, T } = identifiers;
+    switch (varAsked) {
+        case "v":
+            return `La célérité est donnée par $v = \\frac{\\lambda}{T} = \\frac{${roundSignificant(l, 1)}}{${roundSignificant(T, 1)}} = ${roundSignificant(v, 1)}$.`;
+            break;
+        case "T":
+            return `La période est donnée par $T = \\frac{\\lambda}{v} = \\frac{${roundSignificant(l, 1)}}{${roundSignificant(v, 1)}} = ${roundSignificant(T, 1)}$.`;
+            break;
+        case "l":
+        default:
+            return `La longueur d'onde est donnée par $\\lambda = v \\times T = ${roundSignificant(v, 1)} \\times ${roundSignificant(T, 1)} = ${roundSignificant(l, 1)}$.`;
+            break;
+    }
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
 const getPeriodicWaveCelerityQuestion = () => {
     const varAsked = random(["v", "T", "l"]);
     let v;
@@ -18,42 +96,21 @@ const getPeriodicWaveCelerityQuestion = () => {
             T = randfloat(1, 10, 1);
             l = randfloat(1, 10, 1);
             v = round(l / T, 1);
-            instruction = `Une onde périodique a une longueur d'onde de $${roundSignificant(l, 1)}\\ \\text{m}$ et une période de $${roundSignificant(T, 1)}\\ \\text{s}$. Quelle est sa célérité ?`;
-            hint = "Utilisez la formule de la célérité: $v = \\frac{\\lambda}{T}$";
-            correction = `La célérité est donnée par $v = \\frac{\\lambda}{T} = \\frac{${roundSignificant(l, 1)}}{${roundSignificant(T, 1)}} = ${roundSignificant(v, 1)}$.`;
-            answer = roundSignificant(v, 1);
             break;
         case "T":
             l = randfloat(1, 10, 1);
             v = randfloat(1, 10, 1);
             T = round(l / v, 1);
-            instruction = `Une onde périodique a une longueur d'onde de $${roundSignificant(l, 1)}\\ \\text{m}$ et une célérité de $${roundSignificant(v, 1)}\\ \\text{m}\\cdot\\text{s}^{-1}$. Quelle est sa période ?`;
-            hint = "Utilisez la formule de la période: $T = \\frac{\\lambda}{v}$";
-            correction = `La période est donnée par $T = \\frac{\\lambda}{v} = \\frac{${roundSignificant(l, 1)}}{${roundSignificant(v, 1)}} = ${roundSignificant(T, 1)}$.`;
-            answer = roundSignificant(T, 1);
             break;
         case "l":
         default:
             v = randfloat(1, 10, 1);
             T = randfloat(1, 10, 1);
             l = round(v * T, 1);
-            instruction = `Une onde périodique a une période de $${roundSignificant(T, 1)}\\ \\text{m}$ et une célérité de $${roundSignificant(v, 1)}\\ \\text{m}\\cdot\\text{s}^{-1}$. Quelle est sa longueur d'onde ?`;
-            hint =
-                "Utilisez la formule de la longueur d'onde: $\\lambda = v \\times T$";
-            correction = `La longueur d'onde est donnée par $\\lambda = v \\times T = ${roundSignificant(v, 1)} \\times ${roundSignificant(T, 1)} = ${roundSignificant(l, 1)}$.`;
-            answer = roundSignificant(l, 1);
             break;
     }
-    const question = {
-        answer,
-        instruction,
-        hint,
-        correction,
-        keys: [],
-        answerFormat: "tex",
-        identifiers: { v, T, l },
-    };
-    return question;
+    const identifiers = { varAsked, v, T, l };
+    return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (n, { answer }) => {
     const propositions = [];
@@ -70,9 +127,7 @@ export const periodicWaveCelerity = {
     id: "periodicWaveCelerity",
     connector: "=",
     label: "Célérité d'une onde periodique",
-    levels: ["1reSpé"],
     isSingleStep: true,
-    sections: ["Ondes"],
     generator: (nb) => getDistinctQuestions(getPeriodicWaveCelerityQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -80,4 +135,5 @@ export const periodicWaveCelerity = {
     isAnswerValid,
     subject: "Physique",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

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,EAST,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA8DF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}
+{"version":3,"file":"calculateWeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/calculateWeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAiGF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}

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

@@ -4,19 +4,66 @@ import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { earthGravity } from "../../../pc/constants/gravity.js";
 const g = +earthGravity.measure.significantPart.toFixed(2);
-const getCalculateWeightQuestion = () => {
-    const exo = generateExercise();
+const getInstruction = (identifiers) => {
+    const { mass } = identifiers;
+    const instruction = `Soit un objet avec une masse de $${mass}\\ \\textrm{kg}$.
+  
+Calculer le poids de cet objet.`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { mass } = identifiers;
+    const answer = (mass * g).toScientific(2);
+    return answer.toTex();
+};
+const getHint = (identifiers) => {
+    const { mass } = identifiers;
+    const hint = `Le poids $P$ se calcule en utilisant la formule :
+  
+$$
+P=m \\cdot g
+$$
+
+où
+
+- m est la masse de l'objet (en $\\textrm{kg}$).
+
+- g est l'accélération due à la gravité (en $\\textrm{m} \\cdot \\textrm{s}^${-1}$).`;
+    return hint;
+};
+const getCorrection = (identifiers) => {
+    const { mass } = identifiers;
+    const answer = getAnswer(identifiers);
+    const correction = `Pour calculer le poids de l'objet, on utilise la formule : 
+  
+$$
+P=m \\cdot g
+$$
+
+On a : 
+
+$$
+P = ${mass.frenchify()} \\times ${g.frenchify()} \\Rightarrow P=${answer}\\ \\textrm{N}
+$$`;
+    return correction;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: exo.answer.toTex(),
-        instruction: exo.instruction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
-        hint: exo.hint,
-        correction: exo.correction,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         answerFormat: "tex",
-        identifiers: { mass: exo.mass },
+        identifiers,
     };
     return question;
 };
+const getCalculateWeightQuestion = () => {
+    const mass = randint(30, 151);
+    const identifiers = { mass: mass };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, mass }) => {
     const propositions = [];
     const weight = mass * g;
@@ -37,29 +84,10 @@ const generatePropositions = (mass) => {
     const second = (randfloat(weight - 100, weight + 100, 2, [weight]) / 10).toScientific(2);
     return [first.toTex(), second.toTex()];
 };
-const generateExercise = () => {
-    const mass = randint(30, 151);
-    const instruction = `Soit un objet avec une masse de $${mass}$ $kg$. Calculer le poids de cet objet.`;
-    const answer = (mass * g).toScientific(2);
-    const hint = `Rappel : le poids $P$ se calcule en utilisant la formule $P=m \\cdot g$. \n \\
-    - m est la masse de l'objet (en kilogrammes, $kg$).\n \\
-    - g est l'accélération due à la gravité (en $m \\cdot s^${-1}$).`;
-    const correction = `Pour calculer le poids de l'objet, on utilise la formule : $P=m \\cdot g$. \n \\
-  $P = ${mass.frenchify()} \\times ${g.frenchify()}$ $\\Rightarrow$ $P=${answer.toTex()}$ $N$`;
-    return {
-        instruction,
-        answer,
-        hint,
-        correction,
-        mass,
-    };
-};
 export const calculateWeight = {
     id: "calculateWeight",
     label: "Calculer le poids d'un objet",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Forces"],
     generator: (nb) => getDistinctQuestions(getCalculateWeightQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -67,4 +95,5 @@ export const calculateWeight = {
     isAnswerValid,
     subject: "Physique",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"weightOnTheMoon.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/weightOnTheMoon.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA6FF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC"}
+{"version":3,"file":"weightOnTheMoon.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/weightOnTheMoon.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA6HF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

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

@@ -1,37 +1,87 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
-import { frenchify } from "../../../math/utils/latex/frenchify.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { round } from "../../../math/utils/round.js";
 import { earthGravity, moonGravity, } from "../../../pc/constants/mechanics/gravitational.js";
 import { coinFlip } from "../../../utils/alea/coinFlip.js";
-const getWeightOnTheMoonQuestion = () => {
-    const originIsMoon = coinFlip();
+const getInstruction = (identifiers) => {
+    const { weight, originIsMoon } = identifiers;
     const origin = originIsMoon ? "Lune" : "Terre";
     const destination = originIsMoon ? "Terre" : "Lune";
-    const weight = round(randfloat(2, 30), 1);
     const gl = moonGravity.measure.toSignificant(1);
     const gt = earthGravity.measure.toSignificant(1);
-    //Pt = m gt  = Pl/gl gt
-    //Pl = m gl  = Pt/gt gl
+    return `Un objet a un poids de $${weight.frenchify()}\\ \\text{N}$ sur la ${origin}. Quel est son poids sur la ${destination} ?
+    
+Données : $g_T = ${gt.toTex()}$, $g_L = ${gl.toTex()}$
+    `;
+};
+const getAnswer = (identifiers) => {
+    const { weight, originIsMoon } = identifiers;
+    const gl = moonGravity.measure.toSignificant(1);
+    const gt = earthGravity.measure.toSignificant(1);
     const answer = round(originIsMoon
         ? (weight / gl.evaluate()) * gt.evaluate()
-        : (weight / gt.evaluate()) * gl.evaluate(), 1) + "N";
-    const question = {
-        answer: frenchify(answer),
-        instruction: `Un objet a un poids de $${weight.frenchify()}\\ \\text{N}$ sur la ${origin}. Quel est son poids sur la ${destination} ?
+        : (weight / gt.evaluate()) * gl.evaluate(), 1).frenchify() + "N";
+    return answer;
+};
+const getHint = (identifiers) => {
+    return "On rappelle que : $m=\\frac{p_T}{g_T}$ et  $m=\\frac{p_L}{g_L}$";
+};
+const getCorrection = (identifiers) => {
+    const { weight, originIsMoon } = identifiers;
+    const gl = moonGravity.measure.toSignificant(1);
+    const gt = earthGravity.measure.toSignificant(1);
+    const answer = getAnswer(identifiers);
+    if (originIsMoon) {
+        return `- Trouver la masse de l'objet en utilisant son poids sur la Lune $p_L$ et l'accélération due à la gravité luanire $g_L$ : 
     
-Données : $g_T = ${gt.toTex()}$, $g_L = ${gl.toTex()}$
-    `,
-        //hint: ` Pour calculer la masse de l'objet sur Terre, utiliser la formule : $m=\\frac{p_T}{g_T}$`,
-        hint: "On rappelle que : $m=\\frac{p_T}{g_T}$ et  $m=\\frac{p_L}{g_L}$",
-        correction: getCorrection(origin, weight, answer, gt, gl),
+$$
+m = \\frac{p_L}{g_L} \\Leftrightarrow m=${round(weight / gl.evaluate(), 1)}\\textrm{kg}
+$$
+
+- Utiliser la masse trouvée et l'accélération due à la gravité sur la Terre $g_T$ pour calculer le poids sur la Terre $p_T$ : 
+
+$$
+p_T = m \\ \\cdot g_T \\Leftrightarrow p_T = ${answer}
+$$`;
+    }
+    return `- Trouver la masse de l'objet en utilisant son poids sur Terre $p_T$ et l'accélération due à la gravité terrestre $g_T$ : 
+      
+$$
+m = \\frac{p_T}{g_T} \\Leftrightarrow m=${round(weight / gt.evaluate(), 1)}\\textrm{kg}
+$$
+
+- Utiliser la masse trouvée et l'accélération due à la gravité sur la Lune $g_L$ pour calculer le poids sur la Lune $p_L$ : 
+
+$$
+p_L = m \\ \\cdot g_L \\Leftrightarrow
+$$
+
+$$
+p_L = ${answer}
+$$
+`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         keys: ["N"],
         answerFormat: "tex",
-        identifiers: { weight, originIsMoon },
+        identifiers,
     };
     return question;
 };
+const getWeightOnTheMoonQuestion = () => {
+    const originIsMoon = coinFlip();
+    const weight = round(randfloat(2, 30), 1);
+    //Pt = m gt  = Pl/gl gt
+    //Pl = m gl  = Pt/gt gl
+    const identifiers = { weight, originIsMoon };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, originIsMoon, weight }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -45,20 +95,6 @@ const getPropositions = (n, { answer, originIsMoon, weight }) => {
     }
     return shuffleProps(propositions, n);
 };
-const getCorrection = (origin, weight, answer, gt, gl) => {
-    switch (origin) {
-        case "Terre":
-            return `1 . Trouver la masse de l'objet en utilisant son poids sur Terre $p_T$ et l'accélération due à la gravité terrestre $g_T$ : \n $m = \\frac{p_T}{g_T} \\Leftrightarrow m=${round(weight / gt.evaluate(), 1)}\\text{kg}$. \n \\
-      2 . Utiliser la masse trouvée et l'accélération due à la gravité sur la Lune $g_L$ pour calculer le poids sur la Lune $p_L$ : $p_L = m \\ \\cdot g_L \\Leftrightarrow$ $p_L = ${frenchify(answer)}$.`;
-        case "Lune":
-            return `1 . Trouver la masse de l'objet en utilisant son poids sur la Lune $p_L$ et l'accélération due à la gravité luanire $g_L$ : 
-      $m = \\frac{p_L}{g_L} \\Leftrightarrow m=${round(weight / gl.evaluate(), 1)}\\text{kg}$. \n \\
-      2 . Utiliser la masse trouvée et l'accélération due à la gravité sur la Terre $g_T$ pour calculer le poids sur la Terre $p_T$ : 
-      $p_T = m \\ \\cdot g_T \\Leftrightarrow p_T = ${frenchify(answer)}$.`;
-        default:
-            return "";
-    }
-};
 const isAnswerValid = (ans, { answer }) => {
     return [answer, answer.replace("N", "")].includes(ans);
 };
@@ -66,9 +102,7 @@ export const weightOnTheMoon = {
     id: "weightOnTheMoon",
     connector: "=",
     label: "Passer du poids sur la Lune au poids sur la Terre",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Forces"],
     generator: (nb) => getDistinctQuestions(getWeightOnTheMoonQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -76,4 +110,5 @@ export const weightOnTheMoon = {
     isAnswerValid,
     subject: "Physique",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/index.d.ts

@@ -128,19 +128,20 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     type: number;
     flip: number;
+    subFlip: boolean;
     a: number;
     b: number;
     c: number;
     d: number;
 }, {}> | Exercise<{
-    nodeIds: any;
+    nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     type: number;
     subType: number;
 }, {}> | Exercise<{
-    nodeIds: any;
+    nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     type: number;
 }, {}> | Exercise<{
-    nodeIds: any;
+    nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     type: number;
 }, {}> | Exercise<{
     nb: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
@@ -160,6 +161,7 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     scale: number;
     isSmallScale: boolean;
+    isFakeAsked: boolean;
     fakeDistance: number;
 }, {}> | Exercise<{
     coeffIds: any;
@@ -645,9 +647,9 @@ declare const mathExercises: (Exercise<{
     initialY: number;
 }, {}> | Exercise<{
     type: string;
-    d: number;
-    e: number;
-    f: number | undefined;
+    randFuncIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    equaDiffIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    isSolution: boolean;
 }, {}> | Exercise<{
     a: number;
     b: number;
@@ -1149,6 +1151,8 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     A: number[];
     B: number[];
+    startLetter: string;
+    endLetter: string;
 }, {}> | Exercise<{
     xu: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     yu: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
@@ -1192,6 +1196,7 @@ declare const mathExercises: (Exercise<{
     caracAsked: string;
     uPoints: number[][];
     vPoints: number[][];
+    isTrue: boolean;
 }, {}> | Exercise<{
     a: number;
     b: number;
@@ -1322,7 +1327,7 @@ declare const mathExercises: (Exercise<{
     commands: string[];
 }, {}> | Exercise<{
     type: number;
-    commands: string[];
+    objIds: import("./math/geometry/segment.js").SegmentIdentifiers | import("./math/geometry/ray.js").RayIdentifiers | import("./math/geometry/line.js").LineIdentifiers;
 }, {}> | Exercise<{
     isAskingLength: boolean;
     isSegmentHeight: boolean;
@@ -1465,8 +1470,12 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     type: number;
     to: string;
-    from: string | undefined;
+    from: "+" | "-" | undefined;
+    aPositive?: boolean;
     a: number | undefined;
+    b?: number;
+    c?: number;
+    polyPoints?: number[][];
 }, {}> | Exercise<{
     a: string;
     b: string;
@@ -1477,6 +1486,8 @@ declare const mathExercises: (Exercise<{
     AjCoeff: number;
     BiCoeff: number;
     BjCoeff: number;
+    i: number;
+    j: number;
 }, {}> | Exercise<{
     isPercentToDecimal: boolean;
     nb: number;
@@ -2148,9 +2159,9 @@ declare const pcExercises: (Exercise<{
     initialY: number;
 }, {}> | Exercise<{
     type: string;
-    d: number;
-    e: number;
-    f: number | undefined;
+    randFuncIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    equaDiffIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    isSolution: boolean;
 }, {}> | Exercise<{
     b: number;
     secondPoint: number[];
@@ -2220,10 +2231,9 @@ declare const pcExercises: (Exercise<{
     givenAngle: number;
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
 }, {}> | Exercise<{
-    reactionArray: import("./pc/constants/molecularChemistry/reaction.js").ReactionSpecies[];
-}, {}> | Exercise<{
-    reactionArray: import("./pc/constants/molecularChemistry/reaction.js").ReactionSpecies[];
-    randomSpacieIndex: number;
+    epsilon: number;
+    l: number;
+    molecule: string;
 }, {}> | Exercise<{
     concentrationMere: number;
     volumeFille: number;
@@ -2253,6 +2263,18 @@ declare const pcExercises: (Exercise<{
     randomMaterial1: number;
     randomMaterial2: number;
     ramdonAngleIncidenceDeg: number;
+}, {}> | Exercise<{
+    atomicMass: number;
+    atomicNumber: number;
+    isAsking: string;
+    symbol: string;
+}, {}> | Exercise<{
+    isAsking: string;
+    enetringLightX: number;
+    enetringLightY: number;
+}, {}> | Exercise<{
+    order: number;
+    multiplier: number;
 }, {}> | Exercise<{
     frequency1: number;
     frequency2: number;
@@ -2268,6 +2290,7 @@ declare const pcExercises: (Exercise<{
     period: number;
     frequency: number;
     splinePoints: number[][];
+    isAsking: "p\u00E9riode" | "fr\u00E9quence";
 }, {}> | Exercise<{
     xA: number;
     yA: number;
@@ -2327,6 +2350,7 @@ declare const pcExercises: (Exercise<{
 }, {}> | Exercise<{
     lightYear: number;
 }, {}> | Exercise<{
+    varAsked: string;
     v: number;
     l: number;
     T: number;
@@ -2395,7 +2419,14 @@ declare const pcExercises: (Exercise<{
     vA: number;
     vB: number;
     cB: number;
-}, {}> | Exercise<{}, {}> | Exercise<{
+}, {}> | Exercise<{
+    reactionArray: import("./pc/constants/molecularChemistry/reaction.js").ReactionSpecies[];
+}, {}> | Exercise<{
+    reactionArray: import("./pc/constants/molecularChemistry/reaction.js").ReactionSpecies[];
+    randomSpacieIndex: number;
+}, {}> | Exercise<{
+    molecule: string;
+}, {}> | Exercise<{
     mol: number;
     molarMass: number;
 }, {}> | Exercise<{
@@ -2490,10 +2521,14 @@ declare const pcExercises: (Exercise<{
     efficiency: number;
     variable: "P_in" | "P_out" | "\u03B7";
 }, {}> | Exercise<{
-    norm: number;
+    delta: number;
+    constant: number;
+    step: number;
+    speedVectorX1: number;
 }, {}> | Exercise<{
-    ggbCommands: string[];
     movementType: string;
+    a: number;
+    b: number;
 }, {}> | Exercise<{
     distance: {
         value: number;
@@ -2505,20 +2540,17 @@ declare const pcExercises: (Exercise<{
     };
 }, {}> | Exercise<{
     typeOfAcceleration: string;
-    ggbCommands: string[];
+    step: number;
 }, {}> | Exercise<{
     object1: string;
     object2: string;
     reference: "\u00E0 l'autre" | "au sol";
+    isAskingObject1: boolean;
 }, {}> | Exercise<{
     speed: number;
     distance: number;
     deltaTime: number;
     target: "vitesse moyenne" | "distance" | "temps";
-}, {}> | Exercise<{
-    epsilon: number;
-    l: number;
-    molecule: string;
 }, {}> | Exercise<{
     moleculeName: string;
     concentration: number;
@@ -2537,22 +2569,11 @@ declare const pcExercises: (Exercise<{
     molarMass: number;
     variable: "C" | "t" | "M";
 }, {}> | Exercise<{
-    wavelengths: import("./pc/measure/measure.js").Measure[];
+    wavelengths: number[];
     targetColor: "bleue" | "verte" | "rouge";
-    energy: import("./pc/measure/measure.js").Measure;
-}, {}> | Exercise<{
-    atomicMass: number;
-    atomicNumber: number;
-    isAsking: string;
-    symbol: string;
 }, {}> | Exercise<{
-    commands: string[];
-}, {}> | Exercise<{
-    order: number;
-    multiplier: number;
-}, {}> | Exercise<{
-    E: number;
-    S: number;
+    E: number[];
+    S: number[];
 }, {}>)[];
 export { mathExercises, pcExercises, Exercise, Question, parseAlgebraic };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAG7D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/latexTester.js

@@ -23,13 +23,13 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
                 if (inDoubleDollarMode &&
                     nextNextChar !== undefined &&
                     nextNextChar !== "\n") {
-                    throw new Error(`Whitespace missing after start double dollar, got char ${nextNextChar}`);
+                    throw new Error(`Whitespace missing after start double dollar, got char ${nextNextChar}, latex :     ${latex}`);
                 }
                 if (!inDoubleDollarMode &&
                     nextNextChar !== undefined &&
                     nextNextChar !== "\n" &&
                     nextNextChar !== " ") {
-                    throw new Error(`Whitespace missing after end double dollar, got char ${nextNextChar}`);
+                    throw new Error(`Whitespace missing after end double dollar, got char ${nextNextChar} latex :     ${latex}`);
                 }
                 i++;
             }
@@ -228,4 +228,9 @@ const validCmds = [
     "\\lambda",
     "\\ell",
     "\\cancel",
+    "\\sum",
+    "\\parallel",
+    "\\Rightarrow",
+    "\\eta",
+    "\\Leftrightarrow",
 ];