math-exercises 3.0.68 → 3.0.69

package/lib/exercises/pc/forces/calculateNormalOrFrictionForce.js

@@ -2,91 +2,119 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercis
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
 import { earthGravity } from "../../../pc/constants/gravity.js";
 import { random } from "../../../utils/alea/random.js";
-const theta = Math.PI / 4;
-const g = +earthGravity.measure.significantPart.toFixed(2);
+const getHint = (identifiers) => {
+    const hint = `La somme des forces exercées sur un objet en équilibre est nulle :
+  
+$$
+\\sum\\overrightarrow{F} = 0
+$$`;
+    return hint;
+};
+const getInstruction = (identifiers) => {
+    const { mass, isAsking } = identifiers;
+    const instruction = `Soit un système représenté par un bloc en équilibre sur un plan incliné, soumis à trois forces :
+
+- Le poids du bloc $P$. 
+- La force de réaction normale $R$.
+- La force de frottement $f$.
+
+Les données du problème sont les suivantes :
+  
+- La masse du bloc : $m = ${mass}\\ \\textrm{kg}$
+- L'angle du plan incliné par rapport à l'horizontale : $\\alpha = 45^{\\circ}$
+  
+Calculer la force de ${isAsking} en $\\textrm{N}$, arrondie au centième.`;
+    return instruction;
+};
 const getCalculateNormalOrFrictionForceQuestion = () => {
-    const exo = generateExercise();
+    const mass = randint(10, 31);
+    const isAsking = random(["réaction normale", "frottement"]);
+    const identifiers = { mass, isAsking };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: exo.answer,
-        instruction: exo.instruction,
-        hint: exo.hint,
-        correction: exo.correction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { mass: exo.mass, isAsking: exo.isAsking },
+        identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer, mass, isAsking }) => {
+const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
-    const correctAns = getAnswer(isAsking, mass);
+    const correctAns = getAnswer(identifiers).unfrenchify();
     addValidProp(propositions, answer);
-    generatePropositions(mass, isAsking).forEach((value) => tryToAddWrongProp(propositions, value));
+    generatePropositions(identifiers).forEach((value) => tryToAddWrongProp(propositions, value));
     while (propositions.length < n) {
         let random = randfloat(correctAns - 20, correctAns + 21, 2, [correctAns]);
         tryToAddWrongProp(propositions, random.frenchify());
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, mass, isAsking }) => {
-    const scientificAnswer = getAnswer(isAsking, mass).toScientific(2).toTex();
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const scientificAnswer = getAnswer(identifiers)
+        .unfrenchify()
+        .toScientific(2)
+        .toTex();
     return [answer, scientificAnswer].includes(ans);
 };
-const generatePropositions = (mass, isAsking) => {
+const generatePropositions = (identifiers) => {
+    const { mass, isAsking } = identifiers;
     const isNotAsking = isAsking === "réaction normale" ? "frottement" : "réaction normale";
-    const first = (-getAnswer(isNotAsking, mass)).frenchify();
-    return [first];
-};
-const generateExercise = () => {
-    const mass = randint(10, 31);
-    const isAsking = random(["réaction normale", "frottement"]);
-    const instruction = `Soit un système représenté par un bloc en équilibre sur un plan incliné, soumis à trois forces :
-
-- Le poids du bloc $P$. 
-- La force de réaction normale $R$.
-- La force de frottement $f$.
-
-Les données du problème sont les suivantes :
-
-- La masse du bloc : $m = ${mass}\\ kg$
-- L'angle du plan incliné par rapport à l'horizontale : $\\alpha = 45^{\\circ}$
-
-Calculer la force de ${isAsking} en $N$, arrondie au centième.`;
-    const answer = getAnswer(isAsking, mass).frenchify();
-    const hint = `Rappel : la somme des forces exercées sur un objet en équilibre est nulle $\\sum\\overrightarrow{F} = 0$`;
-    const correction = getCorrection(isAsking, answer);
-    return {
-        instruction,
-        answer,
-        hint,
-        correction,
-        isAsking,
+    const first = (-getAnswer({
         mass,
-    };
+        isAsking: isNotAsking,
+    }).unfrenchify()).frenchify();
+    return [first];
 };
-const getAnswer = (isAsking, mass) => {
+const generateExercise = () => { };
+const getAnswer = (identifiers) => {
+    const { mass, isAsking } = identifiers;
+    const theta = Math.PI / 4;
+    const g = +earthGravity.measure.significantPart.toFixed(2);
     const weight = mass * g;
     return isAsking === "réaction normale"
-        ? +(Math.cos(theta) * weight).toFixed(2)
-        : -(Math.sin(theta) * weight).toFixed(2);
+        ? round(Math.cos(theta) * weight, 2).frenchify()
+        : round(-(Math.sin(theta) * weight), 2).frenchify();
 };
-const getCorrection = (isAsking, answer) => {
+const getCorrection = (identifiers) => {
+    const { isAsking } = identifiers;
+    const answer = getAnswer(identifiers);
     return isAsking === "réaction normale"
-        ? `1 - Calculer la composante perpendicualire du poids : $P_{\\perp} = \\cos(45°) \\times m \\cdot g$
+        ? `On calcule la composante perpendicualire du poids : 
+    
+$$
+P_{\\perp} = \\cos(45°) \\times m \\cdot g
+$$
   
-  2 - $R = P_{\\perp}\\ \\Rightarrow\\ R = ${answer}\\ N$`
-        : `1 - Calculer la composante parallèle du poids : $P_{\\parallel} = \\sin(45^{\\circ}) \\times m \\cdot g$
+Puis 
+
+$$
+R = P_{\\perp}\\ \\Rightarrow\\ R = ${answer}\\ N
+$$`
+        : `On calcule la composante parallèle du poids : 
+    
+$$
+P_{\\parallel} = \\sin(45^{\\circ}) \\times m \\cdot g
+$$
   
-  2 - $f = -P_{\\parallel}\\ \\Rightarrow\\ f = ${answer}\\ N$`;
+Puis 
+
+$$
+f = -P_{\\parallel}\\ \\Rightarrow\\ f = ${answer}\\ N
+$$`;
 };
 export const calculateNormalOrFrictionForce = {
     id: "calculateNormalOrFrictionForce",
     label: "Calcul de la force normale ou de frottement exercée sur un objet en équilibre",
-    levels: ["1reSpé", "TermSpé"],
     isSingleStep: true,
-    sections: ["Forces"],
     generator: (nb) => getDistinctQuestions(getCalculateNormalOrFrictionForceQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -94,4 +122,5 @@ export const calculateNormalOrFrictionForce = {
     isAnswerValid,
     subject: "Physique",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/forces/electroStaticForce.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"electroStaticForce.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/electroStaticForce.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAUrC,KAAK,iBAAiB,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,iBAAiB,CAAC;IACtB,EAAE,EAAE,iBAAiB,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAoJF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}
+{"version":3,"file":"electroStaticForce.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/electroStaticForce.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,iBAAiB,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,iBAAiB,CAAC;IACtB,EAAE,EAAE,iBAAiB,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA2KF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}

package/lib/exercises/pc/forces/electroStaticForce.js

@@ -7,28 +7,87 @@ import { Measure } from "../../../pc/measure/measure.js";
 import { DistanceUnit } from "../../../pc/units/distanceUnits.js";
 import { ElectricalChargeUnit } from "../../../pc/units/electricalChargeUnit.js";
 import { ForceUnit } from "../../../pc/units/forceUnits.js";
-const getElectroStaticForceQuestion = () => {
-    const exo = getExercise();
+const getInstruction = (identifiers) => {
+    const { qA, qB, distance } = identifiers;
+    const qAMeasure = new Measure(qA.significant, qA.exponent, ElectricalChargeUnit.C);
+    const qBMeasure = new Measure(qB.significant, qB.exponent, ElectricalChargeUnit.C);
+    const dMeasure = new Measure(distance, 0, DistanceUnit.m);
+    const instruction = `Deux charges ponctuelles, $q_A$ et $q_B$,sont placées dans le vide à une distance $d$ l'une de l'autre.
+  
+  Données:
+
+- La charge de $A$ est $q_A=${qAMeasure.toTex()}$
+- La charge de $B$ est $q_B=${qBMeasure.toTex()}$
+- La distance entre les deux charges est $d=${dMeasure.toTex({
+        notScientific: true,
+    })}$
+  
+Calculer la force électrostatique $\\overrightarrow{F}_{A/B}$, arrondie au centième`;
+    return instruction;
+};
+const getAnswerNode = (identifiers) => {
+    const { qA, qB, distance } = identifiers;
+    const qAMeasure = new Measure(qA.significant, qA.exponent, ElectricalChargeUnit.C);
+    const qBMeasure = new Measure(qB.significant, qB.exponent, ElectricalChargeUnit.C);
+    const dMeasure = new Measure(distance, 0, DistanceUnit.m);
+    return coulombConstant
+        .times(qAMeasure)
+        .times(qBMeasure)
+        .divide(dMeasure.times(dMeasure))
+        .toSignificant(2);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const hint = `Utilise la loi de Coulomb :
+
+$$
+F = k_e \\frac{|q_1 \\cdot q_2|}{r^2}
+$$ `;
+    return hint;
+};
+const getCorrection = (identifiers) => {
+    const { qA, qB, distance } = identifiers;
+    const qAMeasure = new Measure(qA.significant, qA.exponent, ElectricalChargeUnit.C);
+    const qBMeasure = new Measure(qB.significant, qB.exponent, ElectricalChargeUnit.C);
+    const dMeasure = new Measure(distance, 0, DistanceUnit.m);
+    const correction = `On applique la loi de Coulomb :
+
+$$
+F = k_e \\frac{|${qAMeasure.toTex()} \\times ${qBMeasure.toTex()}|}{${dMeasure.toTex({ notScientific: true })}^2}
+$$
+
+d'om $F = ${getAnswer(identifiers)}$`;
+    return correction;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: exo.answer.toTex(),
-        instruction: exo.instruction,
-        hint: exo.hint,
-        correction: exo.correction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         keys: ["N"],
         answerFormat: "tex",
-        identifiers: {
-            qA: exo.qA,
-            qB: exo.qB,
-            distance: exo.distance,
-        },
+        identifiers,
     };
     return question;
 };
+const getElectroStaticForceQuestion = () => {
+    const qA = { significant: randint(2, 7), exponent: randint(-7, -3) };
+    const qB = {
+        significant: randint(2, 7, [qA.significant]),
+        exponent: randint(-7, -3),
+    };
+    const distance = randfloat(0, 1, 1);
+    const identifiers = { qA, qB, distance };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, qA, qB, distance }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     generatePropositions(qA, qB, distance).forEach((value) => tryToAddWrongProp(propositions, value.toTex()));
-    const correctAns = getCorrectAns(new Measure(qA.significant, qA.exponent, ElectricalChargeUnit.C), new Measure(qB.significant, qB.exponent, ElectricalChargeUnit.C), new Measure(distance, 0));
+    const correctAns = getAnswerNode({ qA, qB, distance });
     let random;
     while (propositions.length < n) {
         random = new Measure(randfloat(1, 5, 1, [correctAns.significantPart]), correctAns.exponent, ForceUnit.N);
@@ -37,7 +96,7 @@ const getPropositions = (n, { answer, qA, qB, distance }) => {
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer, qA, qB, distance }) => {
-    const correctAns = getCorrectAns(new Measure(qA.significant, qA.exponent, ElectricalChargeUnit.C), new Measure(qB.significant, qB.exponent, ElectricalChargeUnit.C), new Measure(distance, 0, DistanceUnit.m));
+    const correctAns = getAnswerNode({ qA, qB, distance });
     return [
         correctAns.toTex({ hideUnit: true }),
         correctAns.toTex({ hideUnit: true }) + "N",
@@ -55,55 +114,10 @@ const generatePropositions = (qA, qB, distance) => {
         .divide(dMeasure);
     return [first.toSignificant(2), second.toSignificant(2)];
 };
-const getExercise = () => {
-    const qA = { significant: randint(2, 7), exponent: randint(-7, -3) };
-    const qB = {
-        significant: randint(2, 7, [qA.significant]),
-        exponent: randint(-7, -3),
-    };
-    const qAMeasure = new Measure(qA.significant, qA.exponent, ElectricalChargeUnit.C);
-    const qBMeasure = new Measure(qB.significant, qB.exponent, ElectricalChargeUnit.C);
-    const distance = randfloat(0, 1, 1);
-    const dMeasure = new Measure(distance, 0, DistanceUnit.m);
-    const instruction = `Deux charges ponctuelles, $q_A$ et $q_B$,sont placées dans le vide à une distance $d$ l'une de l'autre.
-  
-  Données:
-  - La charge de $A$ est $q_A=${qAMeasure.toTex()}$
-  - La charge de $B$ est $q_B=${qBMeasure.toTex()}$
-  - La distance entre les deux charges est $d=${dMeasure.toTex({
-        notScientific: true,
-    })}$
-  
-  Cacluler la force électrostatique $\\overrightarrow{F}_{A/B}$, arrondie au centième`;
-    const answer = getCorrectAns(qAMeasure, qBMeasure, dMeasure);
-    const hint = `Rappel de la loi de Coulomb :
-  - $F = k_e \\frac{|q_1 \\cdot q_2|}{r^2}$ `;
-    const correction = `Appliquer la loi de Coulomb :
-1. $F = k_e \\frac{|${qAMeasure.toTex()} \\times ${qBMeasure.toTex()}|}{${dMeasure.toTex({ notScientific: true })}^2}$
-2. $F = ${answer.toTex()}$`;
-    return {
-        instruction,
-        answer,
-        hint,
-        correction,
-        qA,
-        qB,
-        distance,
-    };
-};
-const getCorrectAns = (qA, qB, distance) => {
-    return coulombConstant
-        .times(qA)
-        .times(qB)
-        .divide(distance.times(distance))
-        .toSignificant(2);
-};
 export const electroStaticForce = {
     id: "electroStaticForce",
     label: "Application de la loi de Coulomb",
-    levels: ["1reSpé"],
     isSingleStep: true,
-    sections: ["Forces"],
     generator: (nb) => getDistinctQuestions(getElectroStaticForceQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -111,4 +125,5 @@ export const electroStaticForce = {
     isAnswerValid,
     subject: "Physique",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/forces/forceWork.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"forceWork.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/forceWork.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAoDF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAa3C,CAAC"}
+{"version":3,"file":"forceWork.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/forceWork.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAuEF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAY3C,CAAC"}

package/lib/exercises/pc/forces/forceWork.js

@@ -6,18 +6,34 @@ import { randint } from "../../../math/utils/random/randint.js";
 import { roundSignificant } from "../../../math/utils/round.js";
 import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode.js";
 import { random } from "../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { length, forceValue, angleDegree } = identifiers;
+    const angle = remarkableTrigoValues.find((v) => v.degree === angleDegree);
+    return `Soit une force $\\overrightarrow F$ constante dont le point d'application se déplace d'une position $A$ à une position $B$ telle que $F = ${roundSignificant(forceValue, 1)}\\ \\textrm{N}$, $AB = ${roundSignificant(length, 1)}\\ \\textrm{m}$ et $\\widehat{\\left(\\overrightarrow F ; \\overrightarrow{AB}\\right)} = ${angle.degree}^{\\circ}$. 
+  
+Calculer le travail de la force $\\overrightarrow F$ lors du déplacement de $A$ vers $B$.`;
+};
+const getAnswer = (identifiers) => {
+    const { length, forceValue, angleDegree } = identifiers;
+    const angle = remarkableTrigoValues.find((v) => v.degree === angleDegree);
+    const answer = new MultiplyNode(length.toTree(), new MultiplyNode(angle.cos, forceValue.toTree())).evaluate({});
+    const rounded = roundSignificant(answer, 1);
+    return rounded + "J";
+};
 const getForceWorkQuestion = () => {
     const length = randint(1, 10);
     const forceValue = randint(1, 10);
     const angle = random(remarkableTrigoValues.filter((v) => v.degree > 0 && v.degree < 180));
-    const answer = new MultiplyNode(length.toTree(), new MultiplyNode(angle.cos, forceValue.toTree())).evaluate({});
-    const rounded = roundSignificant(answer, 1);
+    const identifiers = { length, forceValue, angleDegree: angle.degree };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: rounded + "J",
-        instruction: `Soit une force $\\overrightarrow F$ constante dont le point d'application se déplace d'une position $A$ à une position $B$ telle que $F = ${roundSignificant(forceValue, 1)}\\ \\text{N}$, $AB = ${roundSignificant(length, 1)}\\ \\text{m}$ et $\\widehat{\\left(\\overrightarrow F ; \\overrightarrow{AB}\\right)} = ${angle.degree}^{\\circ}$. Calculer le travail de la force $\\overrightarrow F$ lors du déplacement de $A$ vers $B$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["J", "timesTenPower"],
         answerFormat: "tex",
-        identifiers: { length, forceValue, angleDegree: angle.degree },
+        identifiers,
     };
     return question;
 };
@@ -36,13 +52,12 @@ export const forceWork = {
     id: "forceWork",
     connector: "=",
     label: "Calculer le travail d'une force",
-    levels: ["1reSpé"],
     isSingleStep: true,
-    sections: ["Forces"],
     generator: (nb) => getDistinctQuestions(getForceWorkQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Physique",
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/math/proportionnalityCoeffFromLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proportionnalityCoeffFromLine.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/math/proportionnalityCoeffFromLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA2EF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAe/D,CAAC"}
+{"version":3,"file":"proportionnalityCoeffFromLine.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/math/proportionnalityCoeffFromLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA2EF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAa/D,CAAC"}

package/lib/exercises/pc/math/proportionnalityCoeffFromLine.js

@@ -66,9 +66,7 @@ export const proportionnalityCoeffFromLine = {
     id: "proportionnalityCoeffFromLine",
     connector: "=",
     label: "Déterminer le coefficient de proportionnalité à l'aide d'une droite",
-    levels: ["3ème", "2nde", "1reESM", "2ndPro", "1rePro", "1reTech", "1reSpé"],
     isSingleStep: false,
-    sections: ["Droites", "Fonctions affines"],
     generator: (nb) => getDistinctQuestions(getProportionnalityCoeffFromLineQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,

package/lib/index.d.ts

@@ -758,6 +758,7 @@ declare const mathExercises: (Exercise<{
     yValue: number;
     fSplinePoints: number[][];
     gSplinePoints: number[][];
+    xSolutions: number[];
 }, {}> | Exercise<{
     yValue: number;
     fSplinePoints: number[][];
@@ -803,6 +804,7 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
+    isDevForm: boolean;
 }, {}> | Exercise<{
     a: number;
     b: number;
@@ -870,6 +872,7 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
+    isDevForm: boolean;
 }, {}> | Exercise<{
     a: number;
     b: number;
@@ -914,7 +917,6 @@ declare const mathExercises: (Exercise<{
     b: number;
 }, {}> | Exercise<{
     tenthPower: number;
-    nbTex: string;
 }, {}> | Exercise<{
     a: number;
     powered: number;
@@ -1302,6 +1304,8 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     A: number[];
     B: number[];
+    nameA: string;
+    nameB: string;
 }, {}> | Exercise<{
     lengths: number[];
 }, {}> | Exercise<{
@@ -2152,7 +2156,6 @@ declare const pcExercises: (Exercise<{
     secondPoint: number[];
 }, {}> | Exercise<{
     tenthPower: number;
-    nbTex: string;
 }, {}> | Exercise<{
     a: number;
     powered: number;
@@ -2455,8 +2458,6 @@ declare const pcExercises: (Exercise<{
 }, {}> | Exercise<{
     substance: string;
     mass: number;
-    latentHeat: number;
-    energy: number;
 }, {}> | Exercise<{
     isAsking: string;
     mass: number;

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.68",
+  "version": "3.0.69",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [