math-exercises 2.2.3 → 2.2.5

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

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MotionReferenceExercise = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const situations = [
+    {
+        object1: "avion de chasse",
+        object2: "ravitailleur",
+        context: "Vous observez un ravitaillement en vol. Un avion de chasse et un ravitailleur maintiennent une position relative constante pendant le ravitaillement.",
+        gender1: "masculin",
+        gender2: "masculin",
+        hints: {
+            "à l'autre": "Les deux avions maintiennent une position relative constante.",
+            "au sol": "Les deux avions se déplacent ensemble dans le ciel.",
+        },
+        corrections: {
+            "à l'autre": "Les avions ne sont pas en mouvement l'un par rapport à l'autre car ils maintiennent une position relative constante pendant le ravitaillement. Cela signifie que leur vitesse et direction sont les mêmes.",
+            "au sol": "Les avions sont en mouvement par rapport au sol, car ils volent dans le ciel. Même s'ils restent proches l'un de l'autre, ils se déplacent tous les deux par rapport à la Terre.",
+        },
+    },
+    {
+        object1: "passager",
+        object2: "train",
+        context: "Un passager est assis à l'intérieur d'un train qui roule à une vitesse constante sur une ligne droite.",
+        gender1: "masculin",
+        gender2: "masculin",
+        hints: {
+            "à l'autre": "Le passager est à l'intérieur du train en mouvement.",
+            "au sol": "Le train se déplace sur les rails.",
+        },
+        corrections: {
+            "à l'autre": "Le passager n'est pas en mouvement par rapport au train car il est assis à l'intérieur du train en mouvement. Pour un observateur à l'intérieur du train, le passager reste immobile.",
+            "au sol": "Le train est en mouvement par rapport au sol car il roule sur les rails. Pour un observateur extérieur au train, il est évident que le train se déplace.",
+        },
+    },
+    {
+        object1: "conducteur",
+        object2: "voiture",
+        context: "Un conducteur est au volant d'une voiture qui circule sur une autoroute.",
+        gender1: "masculin",
+        gender2: "féminin",
+        hints: {
+            "à l'autre": "Le conducteur est au volant de la voiture en mouvement.",
+            "au sol": "La voiture roule sur l'autoroute.",
+        },
+        corrections: {
+            "à l'autre": "Le conducteur n'est pas en mouvement par rapport à la voiture car il est au volant de celle-ci. Pour lui, il reste à la même place dans la voiture, même si celle-ci se déplace.",
+            "au sol": "La voiture est en mouvement par rapport au sol car elle roule sur l'autoroute. Cela signifie que la voiture change de position par rapport à la route et au paysage environnant.",
+        },
+    },
+    {
+        object1: "enfant",
+        object2: "manège",
+        context: "Un enfant est assis dans un manège qui tourne à une vitesse constante.",
+        gender1: "masculin",
+        gender2: "masculin",
+        hints: {
+            "à l'autre": "L'enfant est assis dans le manège en mouvement.",
+            "au sol": "Le manège tourne sur place.",
+        },
+        corrections: {
+            "à l'autre": "L'enfant n'est pas en mouvement par rapport au manège car il est assis dedans. Pour un observateur sur le manège, l'enfant reste à la même place.",
+            "au sol": "Le manège est en mouvement par rapport au sol car il tourne sur place. Même si l'enfant reste assis au même endroit dans le manège, le manège tout entier tourne par rapport au sol.",
+        },
+    },
+    {
+        object1: "Terre",
+        object2: "Lune",
+        context: "Vous observez la Terre et la Lune depuis l'espace. La Terre tourne sur elle-même et autour du Soleil, tandis que la Lune tourne autour de la Terre.",
+        gender1: "féminin",
+        gender2: "féminin",
+        hints: {
+            "à l'autre": "La Lune tourne autour de la Terre.",
+            "au sol": "La Terre et la Lune sont en mouvement dans l'espace.",
+        },
+        corrections: {
+            "à l'autre": "La Lune est en mouvement par rapport à la Terre car elle tourne autour de celle-ci. Pour un observateur sur la Terre, la position de la Lune change continuellement dans le ciel.",
+            "au sol": "La Terre et la Lune sont en mouvement par rapport au sol, car elles se déplacent dans l'espace. La Terre tourne sur elle-même et autour du Soleil, et la Lune tourne autour de la Terre.",
+        },
+    },
+];
+const references = ["à l'autre", "au sol"];
+const determineCorrectAnswer = (situation, reference) => {
+    if (reference === "à l'autre") {
+        if ((situation.object1 === "Terre" && situation.object2 === "Lune") ||
+            (situation.object1 === "Lune" && situation.object2 === "Terre")) {
+            return "Oui";
+        }
+        return "Non";
+    }
+    else if (reference === "au sol") {
+        if (situation.object1 === "Terre" && situation.object2 === "Lune") {
+            return "Non";
+        }
+        else if (situation.object1 === "Lune" && situation.object2 === "Terre") {
+            return "Oui";
+        }
+        return "Oui";
+    }
+    return "On ne peut pas savoir";
+};
+const getMotionReferenceQuestion = () => {
+    const situationIndex = (0, randint_1.randint)(0, situations.length);
+    const situation = situations[situationIndex];
+    const referenceIndex = (0, randint_1.randint)(0, references.length);
+    const reference = references[referenceIndex];
+    const objectToCheckIndex = (0, coinFlip_1.coinFlip)();
+    const objectToCheck = objectToCheckIndex
+        ? situation.object1
+        : situation.object2;
+    const otherObject = situation.object1 === objectToCheck ? situation.object2 : situation.object1;
+    const referenceText = reference === "à l'autre" ? otherObject : "sol";
+    const isMasculine = objectToCheckIndex
+        ? situation.gender1 === "masculin"
+        : situation.gender2 === "masculin";
+    const genderPronoun = isMasculine ? "il" : "elle";
+    const instruction = `Considérez la situation suivante :\n
+  ${situation.context}\n
+  ${(0, requiresApostropheBefore_1.requiresApostropheBefore)(objectToCheck) ? "L'" : "Le "}${objectToCheck} est-${genderPronoun} en mouvement par rapport ${(0, requiresApostropheBefore_1.requiresApostropheBefore)(referenceText) ? "à l'" : "au "}${referenceText} ?`;
+    const correctAnswer = determineCorrectAnswer(situation, reference);
+    const hint = situation.hints[reference];
+    const correction = situation.corrections[reference];
+    const question = {
+        answer: correctAnswer,
+        instruction,
+        hint,
+        correction,
+        keys: [],
+        answerFormat: "raw",
+        identifiers: {
+            object1: situation.object1,
+            object2: situation.object2,
+            reference,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.MotionReferenceExercise = {
+    id: "motionReference",
+    label: "Déterminer le mouvement relatif entre deux objets",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Mécanique"],
+    answerType: "QCU",
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getMotionReferenceQuestion, nb, 10),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+    maxAllowedQuestions: 10,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,5 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {};
+export declare const typeOfAcceleration: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=typeOfAcceleration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typeOfAcceleration.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/typeOfAcceleration.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG,EAAE,CAAC;AAmFtB,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeOfAcceleration = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const randint_1 = require("../../../math/utils/random/randint");
+const random_1 = require("../../../utils/random");
+const getTypeOfAccelerationQuestion = () => {
+    const exo = generateExo();
+    const question = {
+        answer: exo.answer,
+        instruction: exo.instruction,
+        commands: exo.ggb.object.commands,
+        options: exo.ggb.object.getOptions(),
+        coords: exo.ggb.coords,
+        keys: [],
+        answerFormat: "raw",
+        identifiers: {},
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Mouvement accéléré", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Mouvement ralenti", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Mouvement constant", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const generateExo = () => {
+    const typeOfAcceleration = (0, random_1.random)([
+        "Mouvement accéléré",
+        "Mouvement ralenti",
+        "Mouvement constant",
+    ]);
+    const ggb = generateGgb(typeOfAcceleration);
+    const instruction = `D'après le graphique ci-dessous qui représente la position d'un objet en fonction du temps, 
+  
+  déterminez si l'objet est en mouvement accéléré, en mouvement ralenti ou en mouvement constant.`;
+    return {
+        instruction,
+        answer: typeOfAcceleration,
+        ggb,
+    };
+};
+const generateGgb = (typeOfAcceleration) => {
+    const points = getPoints(typeOfAcceleration);
+    return {
+        object: new geogebraConstructor_1.GeogebraConstructor(points.points, {
+            hideAxes: true,
+            hideGrid: true,
+        }),
+        coords: points.coords,
+    };
+};
+const getPoints = (typeOfAcceleration) => {
+    const points = [];
+    let coords = [];
+    let n = 0;
+    let x = 0;
+    let step = (0, randint_1.randint)(3, 14);
+    let variation = 1;
+    if (typeOfAcceleration === "Mouvement accéléré")
+        variation = 1.3;
+    if (typeOfAcceleration === "Mouvement ralenti") {
+        step = (0, randint_1.randint)(10, 21);
+        variation = 0.8;
+    }
+    while (n < 10) {
+        points.push(`Point({${x},4})`);
+        x = x + step;
+        step = step * variation;
+        n++;
+    }
+    coords = [-2, x + 5, -2, 20];
+    return { points, coords };
+};
+exports.typeOfAcceleration = {
+    id: "typeOfAcceleration",
+    label: "Déterminer le type d'accélération du mouvement d'un objet.",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Mécanique"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTypeOfAccelerationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    answerType: "QCM",
+    subject: "Physique",
+};

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

@@ -0,0 +1,5 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {};
+export declare const typeOfMovement: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=typeOfMovement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typeOfMovement.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/typeOfMovement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG,EAAE,CAAC;AAkHtB,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeOfMovement = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const affine_1 = require("../../../math/polynomials/affine");
+const randint_1 = require("../../../math/utils/random/randint");
+const random_1 = require("../../../utils/random");
+const getTypeOfMovementQuestion = () => {
+    const exo = generateExercise();
+    const ggb = exo.ggb;
+    const question = {
+        answer: exo.answer,
+        instruction: exo.instruction,
+        commands: ggb.commands,
+        coords: exo.coords,
+        options: ggb.getOptions(),
+        keys: [],
+        answerFormat: "raw",
+        identifiers: {},
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Rectiligne", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Circulaire", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Curviligne", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir.", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const generateExercise = () => {
+    const movementType = (0, random_1.random)(["Rectiligne", "Circulaire", "Curviligne"]);
+    const ggb = getGgb(movementType);
+    const instruction = `Soit le graphique ci-dessous, représentant la position d'un objet en fonction du temps. \n \\
+Déterminer le type de mouvement de l'objet.`;
+    return {
+        instruction,
+        answer: movementType,
+        movementType,
+        ggb: ggb.ggb,
+        coords: ggb.coords,
+    };
+};
+const getGgb = (movementType) => {
+    let commands = [];
+    let coords = [];
+    let point1;
+    let point2;
+    switch (movementType) {
+        case "Circulaire":
+            const a = (0, randint_1.randint)(1, 5);
+            const b = (0, randint_1.randint)(6, 9);
+            commands = [
+                `Semicircle((${a},4),(${b},8))`,
+                `Point({${a},4})`,
+                `Point({${b},8})`,
+                `Point({${a},8})`,
+            ];
+            coords = [-2, 10, -2, 10];
+            break;
+        case "Rectiligne":
+            const affine = affine_1.AffineConstructor.random({ min: 1, max: 4 }, { min: 1, max: 4 });
+            point1 = `(2,${affine.calculate(2)})`;
+            point2 = `(8,${affine.calculate(8)})`;
+            commands = [`Segment(${point1},${point2})`].concat(getPoints(movementType, { affine }));
+            coords = [-2, 10, -2, affine.calculate(8) + 5];
+            break;
+        case "Curviligne":
+            const random = (0, randint_1.randint)(10, 21);
+            const bRand = (0, randint_1.randint)(1, 5);
+            commands = [`Function(e^sin(x)+${bRand},0,${random})`].concat(getPoints(movementType, { bRand: bRand }));
+            coords = [-2, 10, -2, 10];
+            break;
+    }
+    return {
+        ggb: new geogebraConstructor_1.GeogebraConstructor(commands, {}),
+        coords,
+    };
+};
+const getPoints = (movementType, options) => {
+    const commands = [];
+    switch (movementType) {
+        case "Rectiligne":
+            for (let x = 3; x < 8; x++) {
+                commands.push(`Point({${x},${options.affine.calculate(x)}})`);
+            }
+            break;
+        case "Curviligne":
+            for (let x = 1; x < 9; x++) {
+                commands.push(`Point({${x},${Math.exp(Math.sin(x)) + options.bRand}})`);
+            }
+            break;
+    }
+    return commands;
+};
+exports.typeOfMovement = {
+    id: "typeOfMovement",
+    label: "Déterminer le type de mouvement",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Mécanique"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTypeOfMovementQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCM",
+    subject: "Physique",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"orderOfMagnitude.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/orderOfMagnitude.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA4DF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAalD,CAAC"}

package/lib/exercises/pc/orderOfMagnitude.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orderOfMagnitude = 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 distanceUnits_1 = require("../../pc/units/distanceUnits");
+const measure_1 = require("../../pc/measure/measure");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const powerNode_1 = require("../../tree/nodes/operators/powerNode");
+const ten = new numberNode_1.NumberNode(10);
+const getOrderOfMagnitudeQuestion = () => {
+    const exercise = generateExercise();
+    const question = {
+        answer: `${exercise.answer.toTex()}`,
+        instruction: exercise.instruction,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { order: exercise.order, multiplier: exercise.multiplier },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, order, multiplier }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    generatePropositions(order, multiplier).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value));
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const generatePropositions = (order, multiplier) => {
+    const correctAnswer = multiplier > 5 ? order + 1 : order;
+    const first = new powerNode_1.PowerNode(ten, (correctAnswer - 1).toTree()).toTex() + "m";
+    const second = new measure_1.Measure(multiplier, correctAnswer, distanceUnits_1.DistanceUnit.m).toTex();
+    const third = new powerNode_1.PowerNode(ten, correctAnswer.toTree()).toTex();
+    return [first, second, third];
+};
+const generateExercise = () => {
+    const order = (0, randint_1.randint)(-15, -10);
+    const multiplier = +(0, randfloat_1.randfloat)(1, 11).toFixed(1);
+    const diameter = new measure_1.Measure(multiplier, order, distanceUnits_1.DistanceUnit.m);
+    const answer = multiplier > 5
+        ? new powerNode_1.PowerNode(ten, (order + 1).toTree())
+        : new powerNode_1.PowerNode(ten, order.toTree());
+    const instruction = `Supposons qu'on ait un atome de diamètre $${diameter.toTex()}$. Indiquez l'ordre de grandeur du diamètre de cet atome.`;
+    return {
+        answer,
+        order,
+        diameter,
+        multiplier,
+        instruction,
+    };
+};
+exports.orderOfMagnitude = {
+    id: "orderOfMagnitude",
+    label: "Calcul d'ordre de grandeur",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Chimie organique"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getOrderOfMagnitudeQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Chimie",
+};

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

@@ -1 +1 @@
-{"version":3,"file":"pH.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/pH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAkDF,eAAO,MAAM,EAAE,EAAE,QAAQ,CAAC,WAAW,CAapC,CAAC"}
+{"version":3,"file":"pH.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/pH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAkDF,eAAO,MAAM,EAAE,EAAE,QAAQ,CAAC,WAAW,CAcpC,CAAC"}

package/lib/exercises/pc/pH.js

@@ -58,4 +58,5 @@ exports.pH = {
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"potentialEnergy.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/potentialEnergy.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA8CF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}
+{"version":3,"file":"potentialEnergy.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/potentialEnergy.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAuDF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}

package/lib/exercises/pc/potentialEnergy.js

@@ -5,15 +5,27 @@ const exercise_1 = require("../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
 const frenchify_1 = require("../../math/utils/latex/frenchify");
 const round_1 = require("../../math/utils/round");
+const gravity_1 = require("../../pc/constants/gravity");
+const measure_1 = require("../../pc/measure/measure");
+const distanceUnits_1 = require("../../pc/units/distanceUnits");
+const energyUnit_1 = require("../../pc/units/energyUnit");
+const massUnits_1 = require("../../pc/units/massUnits");
 const shuffle_1 = require("../../utils/shuffle");
 const getPotentialEnergy = () => {
     const mass = Math.floor(Math.random() * 10 + 1); // Masse de l'objet entre 1 et 11 kg
+    const massMeasure = new measure_1.Measure(mass, 0, massUnits_1.MassUnit.kg);
     const height = Math.floor(Math.random() * 50 + 1); // Hauteur par rapport à la référence entre 1 et 51 m
-    const gravitationalAcceleration = 9.81; // Accélération due à la gravité en m/s²
+    const heightMeasure = new measure_1.Measure(height, 0, distanceUnits_1.DistanceUnit.m);
     const potentialEnergy = mass * 9.81 * height;
-    const instruction = `Un objet de masse $${mass} \\ \\text{kg}$ est suspendu à une hauteur de $${height}\\ \\text{m}$. Il est ensuite relâché et tombe librement.
-  $\\\\$ Calculer l'énergie potentielle de l'objet. (Supposons que l'accélération due à la gravité est de $9,81 \\ \\text{m}\\cdot \\text{s}^{-2}$)`;
-    const answer = `${(0, frenchify_1.frenchify)((0, round_1.round)(potentialEnergy, 2))}J`;
+    const instruction = `Un objet de masse $${massMeasure.toTex({
+        notScientific: true,
+    })}$ est suspendu à une hauteur de $${heightMeasure.toTex({
+        notScientific: true,
+    })}$. Il est ensuite relâché et tombe librement.
+  $\\\\$ Calculer l'énergie potentielle de l'objet. (Supposons que l'accélération due à la gravité est de $${gravity_1.earthGravityAcceleration.measure
+        .toSignificant(2)
+        .toTex()}$)`;
+    const answer = `${(0, frenchify_1.frenchify)((0, round_1.round)(potentialEnergy, 2))}${energyUnit_1.EnergyUnit.J.toTex()}`;
     const question = {
         instruction,
         startStatement: "Ep",
@@ -34,7 +46,7 @@ const getPropositions = (n, { answer, height, mass }) => {
     return (0, shuffle_1.shuffle)(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return [ans, ans.replace("J", energyUnit_1.EnergyUnit.J.toTex())].includes(answer);
 };
 exports.potentialEnergy = {
     id: "potentialEnergy",

package/lib/exercises/pc/power/calculatePowerOfLight.d.ts

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

package/lib/exercises/pc/power/calculatePowerOfLight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculatePowerOfLight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/power/calculatePowerOfLight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqFF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}

package/lib/exercises/pc/power/calculatePowerOfLight.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculatePowerOfLight = 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 distanceUnits_1 = require("../../../pc/units/distanceUnits");
+const divideUnit_1 = require("../../../pc/units/divideUnit");
+const powerUnits_1 = require("../../../pc/units/powerUnits");
+const wattUnit_1 = require("../../../pc/units/wattUnit");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const two = new numberNode_1.NumberNode(2);
+const getCalculatePowerOfLightQuestion = () => {
+    const exo = getExercise();
+    const question = {
+        answer: exo.answer,
+        instruction: exo.instruction,
+        keys: [],
+        hint: exo.hint,
+        correction: exo.correction,
+        answerFormat: "tex",
+        identifiers: {
+            E: exo.E.significantPart * Math.pow(10, exo.E.exponent),
+            S: exo.S.significantPart * Math.pow(10, exo.S.exponent),
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, E, S }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer + `\\ ${wattUnit_1.WattUnit.W.toTex()}`);
+    generatePropositions(E, S).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value.toTex({ notScientific: true })));
+    let random;
+    while (propositions.length < n) {
+        random = (0, randint_1.randint)(E * S - 10, E * S + 10, [E]);
+        (0, exercise_1.tryToAddWrongProp)(propositions, new measure_1.Measure(random, 0, wattUnit_1.WattUnit.W).toTex({ notScientific: true }));
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const generatePropositions = (E, S) => {
+    const first = new measure_1.Measure(Math.floor(E / S), 0, wattUnit_1.WattUnit.W);
+    return [first];
+};
+const getExercise = () => {
+    const E = new measure_1.Measure((0, randint_1.randint)(10, 30), 0, new divideUnit_1.DivideUnit(wattUnit_1.WattUnit.W, new powerUnits_1.PowerUnit(distanceUnits_1.DistanceUnit.m, two)));
+    const S = new measure_1.Measure((0, randint_1.randint)(3, 11), 0, new powerUnits_1.PowerUnit(distanceUnits_1.DistanceUnit.m, two));
+    const lightPower = E.times(S).toSignificant(2);
+    const instruction = `Une cellule photovoltaïque est exposée à une lumière dont l'éclairement $E$ est de $${E.toTex({ notScientific: true })}$.\n \\
+  La surface utile $S$ de cette cellule est de $${S.toTex({
+        notScientific: true,
+    })}$. Calculez la puissance lumineuse reçue par la cellule photovoltaïque. $${lightPower.toTex({ notScientific: true })}$`;
+    const hint = `Rappel : La puissance lumineuse reçue $P$, exprimée en $${wattUnit_1.WattUnit.W.toTex()}$, est donnée par la formule :
+- $P=E \\cdot S$
+`;
+    const correction = `En appliquant la formule $P=E \\cdot S$ on obtient : 
+- $P=${E.toTex({ notScientific: true })} \\times ${S.toTex({
+        notScientific: true,
+    })}\\ \\Rightarrow  P=${lightPower.toTex({ notScientific: true })}$`;
+    return {
+        instruction,
+        answer: lightPower.toTex({ hideUnit: true, notScientific: true }),
+        hint,
+        correction,
+        E,
+        S,
+        lightPower,
+    };
+};
+exports.calculatePowerOfLight = {
+    id: "calculatePowerOfLight",
+    label: "Calcul de puissance lumineuse.",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Lumière"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCalculatePowerOfLightQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/power/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC"}