math-exercises 2.2.2 → 2.2.4

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/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,CAavD,CAAC"}

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

@@ -0,0 +1,85 @@
+"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",
+};

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"}

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./calculatePowerOfLight"), exports);

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

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

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

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

package/lib/exercises/pc/recognizeRefractionOrReflectionAngles.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recognizeRefractionOrReflectionAngles = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const colors_1 = require("../../geogebra/colors");
+const geogebraConstructor_1 = require("../../geogebra/geogebraConstructor");
+const randint_1 = require("../../math/utils/random/randint");
+const random_1 = require("../../utils/random");
+const IsAsking = {
+    RefractionAngle: "Angle de réfraction",
+    ReflectionAngle: "Angle de réflexion",
+    IncidenceAngle: "Angle d'incidence",
+};
+const questionAngle = [
+    IsAsking.ReflectionAngle,
+    IsAsking.IncidenceAngle,
+    IsAsking.RefractionAngle,
+];
+const getRecognizeRefractionOrReflectionAnglesQuestion = () => {
+    const exo = generateExercise();
+    const question = {
+        answer: exo.isAsking,
+        instruction: `Un rayon arrive sur la surface de séparation entre deux milieux. Comment appelle-t-on l'angle représenté ci-dessous ?`,
+        keys: [],
+        commands: exo.ggb.commands,
+        coords: exo.coords,
+        options: exo.ggb.getOptions(),
+        answerFormat: "raw",
+        identifiers: {},
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Angle d'incidence", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Angle de réfraction", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Angle de réflexion", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const generateExercise = () => {
+    const enetringLight = { x1: (0, randint_1.randint)(-20, -10), y1: (0, randint_1.randint)(15, 21) };
+    const reflectionLight = { x2: -enetringLight.x1, y2: enetringLight.y1 };
+    const refractingLight = {
+        x2: reflectionLight.x2 - (0, randint_1.randint)(5, 10),
+        y2: -reflectionLight.y2,
+    };
+    const isAsking = (0, random_1.random)(questionAngle);
+    const angle = getAngle(isAsking, enetringLight);
+    const commands = [
+        `E = Vector((${enetringLight.x1},${enetringLight.y1}), (0,0))`,
+        `R = Vector((0,0), (${reflectionLight.x2},${reflectionLight.y2}))`,
+        `I = Vector((0,0), (${refractingLight.x2},${refractingLight.y2}))`,
+        angle,
+        `DashedLine = Line((0,0),(0,5))`,
+        `Y = Line((0,0),(5,0))`,
+        `Text("\\tiny \\text{Surface de séparation}", (-12,0),false,true)`,
+        `Text("\\tiny \\text{Milieu 1}", (9,2.5),false,true)`,
+        `Text("\\tiny \\text{Milieu 2}", (9,0),false,true)`,
+        `YText = Text(RotateText("\\tiny \\text{Rayon incident}",-90°+${getAngle(IsAsking.IncidenceAngle, enetringLight).substring(6)}), (${enetringLight.x1 / 2 - 1.5},${enetringLight.y1 / 2}),false,true)`,
+        `SetLineStyle(DashedLine,2)`,
+        `ShowLabel(Ang,false)`,
+        `SetColor(E,"#F78D04")`,
+        `SetColor(R,"#F78D04")`,
+        `SetColor(I,"#F78D04")`,
+        `SetColor(YText,"${colors_1.orangeDark}")`,
+        `SetFixed(E,true)`,
+        `SetFixed(R,true)`,
+        `SetFixed(I,true)`,
+        `SetFixed(DashedLine,true)`,
+        `SetFixed(Y,true)`,
+        `First = Polygon((15, 0), (15,12), (-15, 12), (-15, 0))`,
+        `Second = Polygon((15, 0), (15,-12), (-15, -12), (-15, 0))`,
+        `SetColor(First,"${colors_1.blueMain}")`,
+        `SetColor(Second,"#0a6a01")`,
+        `SetColor(Ang,"#6a0101")`,
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        hideGrid: true,
+        hideAxes: true,
+    });
+    const coords = [-10, 10, -10, 10];
+    return {
+        enetringLight,
+        reflectionLight,
+        commands,
+        coords,
+        ggb,
+        isAsking,
+    };
+};
+const getAngle = (isAsking, enetringLight = { x1: 0, y1: 0 }) => {
+    switch (isAsking) {
+        case IsAsking.RefractionAngle:
+            return `Ang = Angle(Vector((0,0), (0,-5)),I)`;
+        case IsAsking.ReflectionAngle:
+            return `Ang = Angle(R,Vector((0,0), (0,5)))`;
+        case IsAsking.IncidenceAngle:
+            return `Ang = Angle(Line((0,0), (0,5)),Line((0,0),(${enetringLight.x1},${enetringLight.y1})))`;
+        default:
+            return "";
+    }
+};
+exports.recognizeRefractionOrReflectionAngles = {
+    id: "recognizeRefractionOrReflectionAngles",
+    label: "Reconaitre un anlge de reflexion, de refraction ou d'incidence",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Lumière"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRecognizeRefractionOrReflectionAnglesQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCM",
+    subject: "Physique",
+};

package/lib/exercises/pc/sound/findPeriodOrFrequencyFromGraph.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    period: number;
+    frequency: number;
+    splinePoints: number[][];
+};
+export declare const findPeriodOrFrequencyFromGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findPeriodOrFrequencyFromGraph.d.ts.map

package/lib/exercises/pc/sound/findPeriodOrFrequencyFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findPeriodOrFrequencyFromGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/sound/findPeriodOrFrequencyFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC;CAC1B,CAAC;AAqFF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAchE,CAAC"}