math-exercises 2.2.2 → 2.2.4

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

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateNormalOrFrictionForce = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const randint_1 = require("../../../math/utils/random/randint");
+const gravity_1 = require("../../../pc/constants/gravity");
+const random_1 = require("../../../utils/random");
+const theta = Math.PI / 4;
+const g = +gravity_1.earthGravity.measure.significantPart.toFixed(2);
+const getCalculateNormalOrFrictionForceQuestion = () => {
+    const exo = generateExercise();
+    const question = {
+        answer: exo.answer,
+        instruction: exo.instruction,
+        hint: exo.hint,
+        correction: exo.correction,
+        coords: [-2, 10, -2, 10],
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { mass: exo.mass, isAsking: exo.isAsking },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, mass, isAsking }) => {
+    const propositions = [];
+    const correctAns = getAnswer(isAsking, mass);
+    (0, exercise_1.addValidProp)(propositions, answer);
+    generatePropositions(mass, isAsking).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value));
+    while (propositions.length < n) {
+        let random = (0, randfloat_1.randfloat)(correctAns - 20, correctAns + 21, 2, [correctAns]);
+        (0, exercise_1.tryToAddWrongProp)(propositions, random.frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, mass, isAsking }) => {
+    const scientificAnswer = getAnswer(isAsking, mass).toScientific(2).toTex();
+    return [answer, scientificAnswer].includes(ans);
+};
+const generatePropositions = (mass, isAsking) => {
+    const isNotAsking = isAsking === "réaction normale" ? "frottement" : "réaction normale";
+    const first = (-getAnswer(isNotAsking, mass)).frenchify();
+    return [first];
+};
+const generateExercise = () => {
+    const mass = (0, randint_1.randint)(10, 31);
+    const isAsking = (0, random_1.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°$
+
+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,
+        mass,
+    };
+};
+const getAnswer = (isAsking, mass) => {
+    const weight = mass * g;
+    return isAsking === "réaction normale"
+        ? +(Math.cos(theta) * weight).toFixed(2)
+        : -(Math.sin(theta) * weight).toFixed(2);
+};
+const getCorrection = (isAsking, answer) => {
+    return isAsking === "réaction normale"
+        ? `1 - Calculer 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°) \\times m \\cdot g$
+  
+  2 - $f = -P_{\\parallel}\\ \\Rightarrow\\ f = ${answer}\\ N$`;
+};
+exports.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) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCalculateNormalOrFrictionForceQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Physique",
+};

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

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../exercises/exercise";
+type simplifiedMeasure = {
+    significant: number;
+    exponent: number;
+};
+type Identifiers = {
+    qA: simplifiedMeasure;
+    qB: simplifiedMeasure;
+    distance: number;
+};
+export declare const electroStaticForce: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=electroStaticForce.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"electroStaticForce.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/electroStaticForce.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,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,CAapD,CAAC"}

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

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.electroStaticForce = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const randint_1 = require("../../../math/utils/random/randint");
+const coulomb_1 = require("../../../pc/constants/coulomb");
+const measure_1 = require("../../../pc/measure/measure");
+const distanceUnits_1 = require("../../../pc/units/distanceUnits");
+const electricalChargeUnit_1 = require("../../../pc/units/electricalChargeUnit");
+const forceUnits_1 = require("../../../pc/units/forceUnits");
+const getElectroStaticForceQuestion = () => {
+    const exo = getExercise();
+    const question = {
+        answer: exo.answer.toTex(),
+        instruction: exo.instruction,
+        hint: exo.hint,
+        correction: exo.correction,
+        keys: ["N"],
+        answerFormat: "tex",
+        identifiers: {
+            qA: exo.qA,
+            qB: exo.qB,
+            distance: exo.distance,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, qA, qB, distance }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    generatePropositions(qA, qB, distance).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value.toTex()));
+    const correctAns = getCorrectAns(new measure_1.Measure(qA.significant, qA.exponent, electricalChargeUnit_1.ElectricalChargeUnit.C), new measure_1.Measure(qB.significant, qB.exponent, electricalChargeUnit_1.ElectricalChargeUnit.C), new measure_1.Measure(distance, 0));
+    let random;
+    while (propositions.length < n) {
+        random = new measure_1.Measure((0, randfloat_1.randfloat)(1, 5, 1, [correctAns.significantPart]), correctAns.exponent, forceUnits_1.ForceUnit.N);
+        (0, exercise_1.tryToAddWrongProp)(propositions, random.toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, qA, qB, distance }) => {
+    const correctAns = getCorrectAns(new measure_1.Measure(qA.significant, qA.exponent, electricalChargeUnit_1.ElectricalChargeUnit.C), new measure_1.Measure(qB.significant, qB.exponent, electricalChargeUnit_1.ElectricalChargeUnit.C), new measure_1.Measure(distance, 0, distanceUnits_1.DistanceUnit.m));
+    return [
+        correctAns.toTex({ hideUnit: true }),
+        correctAns.toTex({ hideUnit: true }) + "N",
+        answer,
+    ].includes(ans);
+};
+const generatePropositions = (qA, qB, distance) => {
+    const qAMeasure = new measure_1.Measure(qA.significant, qA.exponent, electricalChargeUnit_1.ElectricalChargeUnit.C);
+    const qBMeasure = new measure_1.Measure(qB.significant, qB.exponent, electricalChargeUnit_1.ElectricalChargeUnit.C);
+    const dMeasure = new measure_1.Measure(distance, 0, distanceUnits_1.DistanceUnit.m);
+    const first = qAMeasure.times(qBMeasure).divide(dMeasure.times(dMeasure));
+    const second = coulomb_1.coulombConstant
+        .times(qAMeasure)
+        .times(qBMeasure)
+        .divide(dMeasure);
+    return [first.toSignificant(2), second.toSignificant(2)];
+};
+const getExercise = () => {
+    const qA = { significant: (0, randint_1.randint)(2, 7), exponent: (0, randint_1.randint)(-7, -3) };
+    const qB = {
+        significant: (0, randint_1.randint)(2, 7, [qA.significant]),
+        exponent: (0, randint_1.randint)(-7, -3),
+    };
+    const qAMeasure = new measure_1.Measure(qA.significant, qA.exponent, electricalChargeUnit_1.ElectricalChargeUnit.C);
+    const qBMeasure = new measure_1.Measure(qB.significant, qB.exponent, electricalChargeUnit_1.ElectricalChargeUnit.C);
+    const distance = (0, randfloat_1.randfloat)(0, 1, 1);
+    const dMeasure = new measure_1.Measure(distance, 0, distanceUnits_1.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 coulomb_1.coulombConstant
+        .times(qA)
+        .times(qB)
+        .divide(distance.times(distance))
+        .toSignificant(2);
+};
+exports.electroStaticForce = {
+    id: "electroStaticForce",
+    label: "Application de la loi de Coulomb",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Forces"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getElectroStaticForceQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

package/lib/exercises/pc/forces/gravitationalAttractionObjectHeight.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    planet: string;
+    mass: number;
+    h: number;
+};
+export declare const gravitationalAttractionObjectHeight: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=gravitationalAttractionObjectHeight.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gravitationalAttractionObjectHeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/gravitationalAttractionObjectHeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiIF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,WAAW,CAcrE,CAAC"}

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

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gravitationalAttractionObjectHeight = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const planets_1 = require("../../../pc/constants/mechanics/planets");
+const gravitational_1 = require("../../../pc/constants/mechanics/gravitational");
+const measure_1 = require("../../../pc/measure/measure");
+const massUnits_1 = require("../../../pc/units/massUnits");
+const getGravitationalAttractionObjectHeightQuestion = () => {
+    const mass = (0, randint_1.randint)(20, 900); // Masse de l'objet en kilogrammes
+    const selectedPlanet = planets_1.planets.find((planet) => planet.name === "Terre"); // Sélectionne la Terre
+    const G = gravitational_1.earthG.measure;
+    const RT = selectedPlanet.radius.convert("m"); // Le rayon de la Terre en mètres
+    const h = (0, randint_1.randint)(1500, 9000); // La hauteur de l'objet en kilomètres
+    const height = new measure_1.Measure(h, 3);
+    const d = height.add(RT);
+    const massKG = new measure_1.Measure(mass, 0, massUnits_1.MassUnit.kg); // Convertir en kilogrammes
+    const massEarth = selectedPlanet.mass;
+    const force = G.times(massKG).times(massEarth).divide(d.times(d));
+    const answer = h.toScientific(2).toTex();
+    const instruction = `On lance un objet de masse $${mass}\\ \\text{kg}$. \n Déterminer la hauteur de cet objet par rapport à la surface de la Terre en $\\text{km}$, à partir de la valeur de la force d'attraction gravitationnelle. (Format de la réponse : Écriture scientifique avec 2 chiffres après la virgule)
+
+Données : 
++ Force d'attraction gravitationnelle : $F = ${force.toSignificant(2).toTex()}$
++ Rayon de la Terre : $R_T = ${selectedPlanet.radius.toTex({
+        scientific: 2,
+    })}$
++ Masse de la Terre : $m_T = ${selectedPlanet.mass.toTex({
+        scientific: 2,
+    })}$
++ $G = ${G.toTex({ scientific: 2 })}$`;
+    const hint = `La force d'attraction gravitationnelle entre deux masses est donnée par la loi universelle de la gravitation :
+  $$F = G \\cdot \\frac{m_1 \\cdot m_2}{d^2}$$
+  où:
+  - $F$ est la force d'attraction gravitationnelle
+  - $G$ est la constante gravitationnelle
+  - $m_1$ et $m_2$ sont les masses des deux objets
+  - $d$ est la distance entre les centres des deux masses.
+
+  Réorganisez cette formule pour isoler la hauteur $h$ à partir de la force $F$ mesurée.`;
+    const correction = `Pour trouver la hauteur $h$, nous réorganisons la loi de la gravitation :
+  $$F = G \\cdot \\frac{m_1 \\cdot m_2}{(R_T + h)^2}$$
+  où:
+  - $F = ${force.toSignificant(2).toTex({})}$
+  - $G = ${G.toTex({ scientific: 2 })}$
+  - $m_1 = ${mass}\\ \\text{kg}$
+  - $m_2 = ${selectedPlanet.mass.toTex({
+        scientific: 2,
+    })}$
+  - $R_T = ${selectedPlanet.radius.toTex({
+        scientific: 2,
+    })}$
+
+  Nous devons convertir le rayon de la Terre $R_T$ en mètres pour le calcul en utilisant le Système International d'Unités (SI).
+
+  Nous résolvons pour $h$ :
+  $$h = \\sqrt{\\frac{G \\cdot m_1 \\cdot m_2}{F}} - R_T$$
+
+  En appliquant les valeurs, nous obtenons :
+  $$h = \\sqrt{\\frac{${G.toTex({
+        scientific: 2,
+    })} \\cdot ${mass} \\cdot ${selectedPlanet.mass.toTex({
+        scientific: 2,
+    })}}{${force.toSignificant(2).toTex()}}} - ${selectedPlanet.radius
+        .convert("m")
+        .toTex({
+        scientific: 2,
+    })}$$
+
+  Après simplification, la hauteur $h$ est approximativement :
+  $$h \\approx ${answer}\\ \\text{km}$$`;
+    const question = {
+        answer,
+        instruction,
+        hint,
+        correction,
+        keys: ["timesTenPower"],
+        answerFormat: "tex",
+        identifiers: { planet: selectedPlanet.name, mass, h },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, mass, h }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const selectedPlanet = planets_1.planets.find((planet) => planet.name === "Terre");
+    const RT = selectedPlanet.radius;
+    const w1 = h * h;
+    const w2 = RT.times(h);
+    const w3 = RT;
+    (0, exercise_1.tryToAddWrongProp)(propositions, w1.toScientific(2).toTex({ hideUnit: true }));
+    (0, exercise_1.tryToAddWrongProp)(propositions, w2.toSignificant(2).toTex({ hideUnit: true }));
+    (0, exercise_1.tryToAddWrongProp)(propositions, w3.toSignificant(2).toTex({ hideUnit: true }));
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(1500, 9000).toScientific(2).toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, h }) => {
+    const height = new measure_1.Measure(h * 0.001, 3);
+    const validanswer1 = new measure_1.Measure(height.significantPart + 0.01, 3);
+    const validanswer2 = new measure_1.Measure(height.significantPart - 0.01, 3);
+    const validanswer3 = new measure_1.Measure(height.significantPart - 0.01, 3);
+    const validanswer4 = new measure_1.Measure(height.significantPart + 0.02, 3);
+    let latexs = [
+        answer,
+        h.toScientific(2).toTex(),
+        validanswer1.toSignificant(2).toTex({ hideUnit: true }),
+        validanswer4.toSignificant(2).toTex({ hideUnit: true }),
+        validanswer2.toSignificant(2).toTex({ hideUnit: true }),
+        validanswer3.toSignificant(2).toTex({ hideUnit: true }),
+    ];
+    console.log(latexs);
+    return latexs.includes(ans);
+};
+exports.gravitationalAttractionObjectHeight = {
+    id: "gravitationalAttractionObjectHeight",
+    connector: "=",
+    label: "Calculer la hauteur d'un objet par rapport à la surface de la terre",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Mécanique gravitationnelle"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getGravitationalAttractionObjectHeightQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

package/lib/exercises/pc/forces/gravitationalAttractionValue.d.ts

@@ -1,5 +1,6 @@
 import { Exercise } from "../../../exercises/exercise";
 type Identifiers = {
+    planet: string;
     mass: number;
 };
 export declare const gravitationalAttractionValue: Exercise<Identifiers>;

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

@@ -1 +1 @@
-{"version":3,"file":"gravitationalAttractionValue.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/gravitationalAttractionValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA8DF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}
+{"version":3,"file":"gravitationalAttractionValue.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/gravitationalAttractionValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAkEF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}

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

@@ -6,54 +6,58 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const randfloat_1 = require("../../../math/utils/random/randfloat");
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
-const earth_1 = require("../../../pc/constants/earth");
-const gravity_1 = require("../../../pc/constants/gravity");
+const planets_1 = require("../../../pc/constants/mechanics/planets");
+const gravitational_1 = require("../../../pc/constants/mechanics/gravitational");
+const measure_1 = require("../../../pc/measure/measure");
+const massUnits_1 = require("../../../pc/units/massUnits");
 const getGravitationalAttractionValueQuestion = () => {
-    const mass = (0, randint_1.randint)(20, 900);
-    //F = G/(Rt^2) * mT * mb
-    const G = gravity_1.earthG.measure;
-    const RT = earth_1.earthRayon.measure.times(1000);
-    const massKG = mass / 1000;
-    const massEarth = earth_1.earthMass.measure;
+    const mass = (0, randint_1.randint)(20, 900); // Masse de l'objet en grammes
+    const selectedPlanet = planets_1.planets.find((planet) => planet.name === "Terre"); // Sélectionne la Terre
+    const G = gravitational_1.earthG.measure;
+    const RT = selectedPlanet.radius.convert("m"); // Le rayon de la Terre en mètres
+    const massKG = new measure_1.Measure(mass, -3, massUnits_1.MassUnit.kg); // Convertir en kilogrammes
+    const massEarth = selectedPlanet.mass;
     const answerMeasure = G.times(massKG).times(massEarth).divide(RT.times(RT));
-    // const answerMeasure = G.times(massKG);
-    console.log(mass, answerMeasure.significantPart, answerMeasure.exponent);
-    const answer = answerMeasure.toTex({ scientific: 2 }) + "N";
+    const answer = answerMeasure.toTex({ scientific: 2 });
     const question = {
         answer,
-        instruction: `On lance un objet de masse $${mass}\\ \\text{g}$. Déterminer la valeur de la force d'attraction gravitationnelle exercée par la Terre sur cet objet.
+        instruction: `On lance un objet de masse $${mass}\\ ${massUnits_1.MassUnit.g.toTex()}$. Déterminer la valeur de la force d'attraction gravitationnelle exercée par la Terre sur cet objet (La hauteur $h$ de l'objet par rapport à la surface de la terre est négligeable).
 
 Données : 
-+ Rayon de la Terre : $R_T = ${earth_1.earthRayon.measure.toTex({
++ Rayon de la Terre : $R_T = ${selectedPlanet.radius.toTex({
             scientific: 2,
-        })}\\ ${earth_1.earthRayon.unit}$
-
-+ Masse de la Terre : $m_T = ${earth_1.earthMass.measure.toTex({ scientific: 2 })}\\ ${earth_1.earthMass.unit}$
-
-+ $G = ${gravity_1.earthG.measure.toTex({ scientific: 2 })}\\ ${gravity_1.earthG.unit}$`,
+        })}$
++ Masse de la Terre : $m_T = ${selectedPlanet.mass.toTex({
+            scientific: 2,
+        })}$
++ $G = ${G.toTex({ scientific: 2 })}$`,
         keys: ["N", "timesTenPower"],
         answerFormat: "tex",
-        identifiers: { mass },
+        identifiers: { planet: selectedPlanet.name, mass },
     };
     return question;
 };
 const getPropositions = (n, { answer, mass }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const G = gravity_1.earthG.measure;
-    const RT = earth_1.earthRayon.measure;
-    const massEarth = earth_1.earthMass.measure;
-    (0, exercise_1.tryToAddWrongProp)(propositions, G.times(mass)
+    const G = gravitational_1.earthG.measure;
+    const selectedPlanet = planets_1.planets.find((planet) => planet.name === "Terre");
+    const RT = selectedPlanet.radius;
+    const massEarth = selectedPlanet.mass;
+    const massKG = new measure_1.Measure(mass, -3);
+    (0, exercise_1.tryToAddWrongProp)(propositions, G.times(massKG)
         .times(massEarth)
         .divide(RT.times(RT))
-        .toTex({ scientific: 2 }) + "N");
+        .toTex({ scientific: 2, hideUnit: true }) + "\\ \\text{N}");
     while (propositions.length < n) {
-        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)((0, randfloat_1.randfloat)(1, 20), 2).frenchify() + "N");
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)((0, randfloat_1.randfloat)(1, 20), 2).toTree().toTex() + "\\ \\text{N}");
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return [answer, answer.replace("N", "")].includes(ans);
+    if (ans === answer)
+        return true;
+    return [answer.replace("\\ N", "N"), answer.replace("\\ N", "")].includes(ans);
 };
 exports.gravitationalAttractionValue = {
     id: "gravitationalAttractionValue",
@@ -61,7 +65,7 @@ exports.gravitationalAttractionValue = {
     label: "Calculer la force d'attraction gravitationnelle",
     levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Forces"],
+    sections: ["Mécanique gravitationnelle"],
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getGravitationalAttractionValueQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,

package/lib/exercises/pc/forces/gravitationalForcePlanets.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+import { Measure } from "../../../pc/measure/measure";
+type Identifiers = {
+    planet: string;
+    mass: Measure;
+    distance: Measure;
+};
+export declare const gravitationalForcePlanets: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=gravitationalForcePlanets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gravitationalForcePlanets.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/gravitationalForcePlanets.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAIlC,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAOnD,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAiJF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gravitationalForcePlanets = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const measure_1 = require("../../../pc/measure/measure");
+const planets_1 = require("../../../pc/constants/mechanics/planets");
+const gravitational_1 = require("../../../pc/constants/mechanics/gravitational");
+const G = gravitational_1.earthG.measure;
+const getGravitationalForcePlanetsQuestion = () => {
+    const planetIndex = (0, randint_1.randint)(0, planets_1.planets.length);
+    const selectedPlanet = planets_1.planets[planetIndex];
+    const massSun = gravitational_1.sunMass.measure;
+    // Convert distance from km to m
+    const distanceInMeters = selectedPlanet.distanceFromSun.convert("m");
+    const force = G.times(selectedPlanet.mass)
+        .times(massSun)
+        .divide(distanceInMeters.times(distanceInMeters))
+        .toSignificant(2);
+    const instruction = `Considérez la planète ${selectedPlanet.name} dans le ${selectedPlanet.system}. 
+  La masse de ${selectedPlanet.name} est de $${selectedPlanet.mass.toTex({
+        scientific: 2,
+    })}$ et la distance entre ${selectedPlanet.name} et le Soleil est de $${selectedPlanet.distanceFromSun.toTex({
+        scientific: 2,
+    })}$. 
+  Calculez la force gravitationnelle exercée par le Soleil sur ${selectedPlanet.name}.
+
+Données:
+- Constante de gravitation universelle: $G = ${G.toTex({
+        scientific: 2,
+    })}$
+- Masse du Soleil: $m_{\\text{soleil}} = ${massSun.toTex({
+        scientific: 2,
+    })}$`;
+    const hint = `Utilisez la formule de la force gravitationnelle.`;
+    const correction = `La force gravitationnelle est donnée par la formule vectorielle :
+  $$\\vec{F}_{\\text{Soleil/${selectedPlanet.name}}} = -G \\cdot \\frac{m_{\\text{soleil}} \\cdot m_{${selectedPlanet.name.charAt(0)}}}{d^2} \\cdot \\vec{u}_{\\text{Soleil→${selectedPlanet.name}}}$$. \n
+  La formule de la force gravitationnelle en valeur est :
+  $$F_{\\text{Soleil/${selectedPlanet.name}}} = G \\cdot \\frac{m_{\\text{soleil}} \\cdot m_{${selectedPlanet.name.charAt(0)}}}{d^2}$$. \n
+  En utilisant les valeurs fournies :
+  $$F_{\\text{Soleil/${selectedPlanet.name}}} = ${G.toTex({
+        scientific: 2,
+    })} \\cdot \\frac{${selectedPlanet.mass.toTex({
+        scientific: 2,
+    })} \\cdot ${massSun.toTex({
+        scientific: 2,
+    })}}{(${distanceInMeters.toTex({
+        scientific: 2,
+    })})^2} = ${force.toTex({ scientific: 2 })}$$. \n
+  Donc, la force gravitationnelle exercée par le Soleil sur ${selectedPlanet.name} est $${force.toTex({ scientific: 2 })}$.`;
+    const question = {
+        answer: force.toTex({ scientific: 2 }),
+        instruction,
+        hint,
+        correction,
+        keys: ["N", "timesTenPower"],
+        answerFormat: "tex",
+        identifiers: {
+            planet: selectedPlanet.name,
+            mass: selectedPlanet.mass,
+            distance: selectedPlanet.distanceFromSun,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, mass, distance }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const massSun = gravitational_1.sunMass.measure;
+    const distanceInMeters = distance.times(1000);
+    const correctAnswer = G.times(mass)
+        .times(massSun)
+        .divide(distanceInMeters.times(distanceInMeters))
+        .toSignificant(2);
+    const wrongAnswer1 = G.times(mass)
+        .times(massSun)
+        .divide(distance.times(distance))
+        .toSignificant(2);
+    const wrongAnswer2 = G.times(mass)
+        .times(massSun)
+        .times(distanceInMeters.times(distanceInMeters))
+        .toSignificant(2);
+    const wrongAnswer3 = G.times(mass)
+        .times(massSun)
+        .divide(distanceInMeters)
+        .toSignificant(2);
+    (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer1.toTex({ scientific: 2, hideUnit: true }) + "\\ \\text{N}");
+    (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer2.toTex({ scientific: 2, hideUnit: true }) + "\\ \\text{N}");
+    (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer3.toTex({ scientific: 2, hideUnit: true }) + "\\ \\text{N}");
+    while (propositions.length < n) {
+        const errorFactor = new measure_1.Measure(1, (0, randint_1.randint)(1, 5));
+        const wrongAnswer = correctAnswer.times(errorFactor);
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toTex({ scientific: 2 }) + "\\ \\text{N}");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    if (ans === answer)
+        return true;
+    return [answer.replace("\\ N", "N"), answer.replace("\\ N", "")].includes(ans);
+};
+exports.gravitationalForcePlanets = {
+    id: "gravitationalForcePlanets",
+    connector: "=",
+    label: "Calculer la force gravitationnelle entre le Soleil et une planète",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Mécanique gravitationnelle"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getGravitationalForcePlanetsQuestion, nb, 8),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+    maxAllowedQuestions: 8,
+};

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

@@ -1,4 +1,9 @@
 export * from "./gravitationalAttractionValue";
 export * from "./forceWork";
 export * from "./pressingForce";
+export * from "./calculateNormalOrFrictionForce";
+export * from "./massWeight";
+export * from "./gravitationalForcePlanets";
+export * from "./gravitationalAttractionObjectHeight";
+export * from "./electroStaticForce";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kCAAkC,CAAC;AACjD,cAAc,cAAc,CAAC;AAC7B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uCAAuC,CAAC;AACtD,cAAc,sBAAsB,CAAC"}

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

@@ -17,3 +17,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./gravitationalAttractionValue"), exports);
 __exportStar(require("./forceWork"), exports);
 __exportStar(require("./pressingForce"), exports);
+__exportStar(require("./calculateNormalOrFrictionForce"), exports);
+__exportStar(require("./massWeight"), exports);
+__exportStar(require("./gravitationalForcePlanets"), exports);
+__exportStar(require("./gravitationalAttractionObjectHeight"), exports);
+__exportStar(require("./electroStaticForce"), exports);
+// export * from "./pressureDifferenceCalculation";