math-exercises 2.1.26-beta.2 → 2.1.26-beta.3

package/lib/exercises/pc/dosage/beerLambertRandomValue.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    moleculeName: string;
+    concentration: number;
+    molarAbsorptivity: number;
+    pathLength: number;
+    absorbance: number;
+    randomIndex: number;
+};
+export declare const BeerLambertRandomValueExercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=beerLambertRandomValue.d.ts.map

package/lib/exercises/pc/dosage/beerLambertRandomValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beerLambertRandomValue.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/dosage/beerLambertRandomValue.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAmJF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAahE,CAAC"}

package/lib/exercises/pc/dosage/beerLambertRandomValue.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeerLambertRandomValueExercise = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const round_1 = require("../../../math/utils/round");
+const molecule_1 = require("../../../pc/molecularChemistry/molecule");
+const random_1 = require("../../../utils/random");
+const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const randint_1 = require("../../../math/utils/random/randint");
+const getBeerLambertRandomValueQuestion = () => {
+    const molecule = (0, random_1.random)(molecule_1.molecules);
+    const concentration = (0, round_1.round)((0, randfloat_1.randfloat)(0.01, 0.1), 2); // Concentration in mol/L
+    const molarAbsorptivity = (0, round_1.round)((0, randfloat_1.randfloat)(10, 100), 1); // Molar absorptivity in L/(mol·cm)
+    const pathLength = (0, round_1.round)((0, randfloat_1.randfloat)(1, 5), 1); // Path length in cm
+    const absorbance = (0, round_1.round)(concentration * molarAbsorptivity * pathLength, 2); // Absorbance
+    const variables = [
+        { name: "concentration", value: concentration, unit: "mol/L" },
+        { name: "molarAbsorptivity", value: molarAbsorptivity, unit: "L/(mol·cm)" },
+        { name: "pathLength", value: pathLength, unit: "cm" },
+        { name: "absorbance", value: absorbance, unit: "" },
+    ];
+    const randomIndex = (0, randint_1.randint)(0, variables.length - 1);
+    const targetVariable = variables[randomIndex];
+    const knownVariables = variables.filter((_, index) => index !== randomIndex);
+    const knownVariablesText = knownVariables
+        .map((v) => `${v.name === "concentration"
+        ? "Concentration"
+        : v.name === "molarAbsorptivity"
+            ? "Coefficient d'absorption molaire"
+            : v.name === "pathLength"
+                ? "Longueur du trajet optique"
+                : "Absorbance"} : ${v.name === "concentration"
+        ? "$C$"
+        : v.name === "molarAbsorptivity"
+            ? "$ε$"
+            : v.name === "pathLength"
+                ? "$\\ell$"
+                : "$A$"} = $${v.value}\\ ${v.unit}$`)
+        .join(",\n");
+    const instruction = `Vous êtes en train de réaliser l'étalonnage d'une solution ${(0, requiresApostropheBefore_1.requiresApostropheBefore)(molecule.name) ? "d'" : "de "}${molecule.name} en utilisant une solution étalon. Vous avez mesuré les données suivantes :\n
+  - ${knownVariablesText}.\n
+  À partir de ces données, déterminez la ${targetVariable.name === "concentration"
+        ? "concentration en mol/L"
+        : targetVariable.name === "molarAbsorptivity"
+            ? "coefficient d'absorption molaire en L/(mol·cm)"
+            : targetVariable.name === "pathLength"
+                ? "longueur du trajet optique en cm"
+                : "absorbance"} de cette solution.`;
+    const hint = `Rappelez-vous la loi de Beer-Lambert : $A = ε \\cdot C \\cdot \\ell$.
+  Réorganisez cette formule pour isoler la variable à trouver.`;
+    const correction = `La loi de Beer-Lambert est donnée par :
+  $A = ε \\cdot \\ell \\cdot C$. En utilisant les valeurs fournies pour $ε$, $C$, et $\\ell$, vous pouvez résoudre pour la variable manquante.
+  Si $A$ est l'absorbance, $ε$ est le coefficient d'absorption molaire, $C$ est la concentration et $\\ell$ est la longueur du trajet optique, alors
+  ${targetVariable.name === "concentration"
+        ? "$C = \\frac{A}{ε \\cdot \\ell}$"
+        : ""}
+  ${targetVariable.name === "molarAbsorptivity"
+        ? "$ε = \\frac{A}{C \\cdot \\ell}$"
+        : ""}
+  ${targetVariable.name === "pathLength"
+        ? "$\\ell = \\frac{A}{ε \\cdot C}$"
+        : ""}
+  ${targetVariable.name === "absorbance" ? "$A = ε \\cdot C \\cdot \\ell$" : ""}`;
+    const question = {
+        answer: targetVariable.value.toTree().toTex(),
+        instruction,
+        hint,
+        correction,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: {
+            moleculeName: molecule.name,
+            concentration,
+            molarAbsorptivity,
+            pathLength,
+            absorbance,
+            randomIndex,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, concentration, molarAbsorptivity, pathLength, absorbance }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, concentration.toTree().toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, molarAbsorptivity.toTree().toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, pathLength.toTree().toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, absorbance.toTree().toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(0, 10, 2).toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, randomIndex, concentration, molarAbsorptivity, pathLength, absorbance, }) => {
+    const variables = [
+        { name: "concentration", value: concentration, unit: "mol/L" },
+        { name: "molarAbsorptivity", value: molarAbsorptivity, unit: "L/(mol·cm)" },
+        { name: "pathLength", value: pathLength, unit: "cm" },
+        { name: "absorbance", value: absorbance, unit: "" },
+    ];
+    const validAnswer = variables[randomIndex].value;
+    const latexs = validAnswer.toTree().toAllValidTexs();
+    return latexs.includes(ans);
+};
+exports.BeerLambertRandomValueExercise = {
+    id: "beerLambertRandomValue",
+    label: "Utiliser la loi de Beer-Lambert",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Spectrophotométrie"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getBeerLambertRandomValueQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Chimie",
+};

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

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

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

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

package/lib/exercises/pc/dosage/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("./beerLambertRandomValue"), exports);

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

@@ -22,6 +22,8 @@ export * from "./mecanicalWaves";
 export * from "./fluids";
 export * from "./electricity";
 export * from "./calibrationCurveOfSolution";
+export * from "./dosage";
+export * from "./spectral";
 /**exos pris des maths */
 export * from "../math/percent/findProportion";
 export * from "../math/calcul/proportionality/proportionalityTable";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,MAAM,CAAC;AACrB,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,QAAQ,CAAC;AACvB,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAE7C,yBAAyB;AACzB,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qDAAqD,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,cAAc,oCAAoC,CAAC;AACnD,cAAc,6CAA6C,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,8CAA8C,CAAC;AAClF,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,iDAAiD,CAAC;AAChE,cAAc,8CAA8C,CAAC;AAC7D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mDAAmD,CAAC;AAClE,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,uCAAuC,CAAC;AACtD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4CAA4C,CAAC;AAC3D,cAAc,+CAA+C,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,sBAAsB,EAAE,MAAM,sDAAsD,CAAC;AAC9F,cAAc,6CAA6C,CAAC;AAC5D,cAAc,8CAA8C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,MAAM,CAAC;AACrB,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,QAAQ,CAAC;AACvB,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAE3B,yBAAyB;AACzB,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qDAAqD,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,cAAc,oCAAoC,CAAC;AACnD,cAAc,6CAA6C,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,8CAA8C,CAAC;AAClF,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,iDAAiD,CAAC;AAChE,cAAc,8CAA8C,CAAC;AAC7D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mDAAmD,CAAC;AAClE,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,uCAAuC,CAAC;AACtD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4CAA4C,CAAC;AAC3D,cAAc,+CAA+C,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,sBAAsB,EAAE,MAAM,sDAAsD,CAAC;AAC9F,cAAc,6CAA6C,CAAC;AAC5D,cAAc,8CAA8C,CAAC"}

package/lib/exercises/pc/index.js

@@ -39,6 +39,8 @@ __exportStar(require("./mecanicalWaves"), exports);
 __exportStar(require("./fluids"), exports);
 __exportStar(require("./electricity"), exports);
 __exportStar(require("./calibrationCurveOfSolution"), exports);
+__exportStar(require("./dosage"), exports);
+__exportStar(require("./spectral"), exports);
 /**exos pris des maths */
 __exportStar(require("../math/percent/findProportion"), exports);
 __exportStar(require("../math/calcul/proportionality/proportionalityTable"), exports);

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

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

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

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

package/lib/exercises/pc/spectral/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("./spectralEnergy"), exports);

package/lib/exercises/pc/spectral/spectralEnergy.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+import { Measure } from "../../../pc/measure/measure";
+type Identifiers = {
+    wavelengths: Measure[];
+    targetColor: "bleue" | "verte" | "rouge";
+    energy: Measure;
+};
+export declare const SpectralEnergyExercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=spectralEnergy.d.ts.map

package/lib/exercises/pc/spectral/spectralEnergy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spectralEnergy.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/spectral/spectralEnergy.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAKnD,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,WAAW,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;IACzC,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AA0IF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAaxD,CAAC"}

package/lib/exercises/pc/spectral/spectralEnergy.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpectralEnergyExercise = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const measure_1 = require("../../../pc/measure/measure");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const randint_1 = require("../../../math/utils/random/randint");
+const quantic_1 = require("../../../pc/constants/quantic");
+const wavelengths = {
+    bleue: { min: 400, max: 455 },
+    verte: { min: 500, max: 560 },
+    rouge: { min: 610, max: 660 },
+};
+const h = new measure_1.Measure(quantic_1.planckConstant.value.significantPart, quantic_1.planckConstant.value.exponent);
+const c = new measure_1.Measure(quantic_1.lightSpeed.value.significantPart, quantic_1.lightSpeed.value.exponent);
+const images = [
+    `https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/emissionSpectrum1.png`,
+    `https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/emissionSpectrum2.png`,
+    `https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/emissionSpectrum3.png`,
+    `https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/emissionSpectrum4.png`,
+    `https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/emissionSpectrum5.png`,
+];
+const getSpectralEnergyQuestion = () => {
+    const wavelengthBlueNm = (0, randint_1.randint)(wavelengths.bleue.min, wavelengths.bleue.max);
+    const wavelengthGreenNm = (0, randint_1.randint)(wavelengths.verte.min, wavelengths.verte.max);
+    const wavelengthRedNm = (0, randint_1.randint)(wavelengths.rouge.min, wavelengths.rouge.max);
+    const wavelengthBlue = new measure_1.Measure(wavelengthBlueNm, -9);
+    const wavelengthGreen = new measure_1.Measure(wavelengthGreenNm, -9);
+    const wavelengthRed = new measure_1.Measure(wavelengthRedNm, -9);
+    const energies = {
+        bleue: h.times(c).divide(wavelengthBlue).toSignificant(2),
+        verte: h.times(c).divide(wavelengthGreen).toSignificant(2),
+        rouge: h.times(c).divide(wavelengthRed).toSignificant(2),
+    };
+    const colors = ["bleue", "verte", "rouge"];
+    const targetColor = colors[(0, randint_1.randint)(0, colors.length - 1)];
+    const targetEnergy = energies[targetColor];
+    const instruction = `Vous travaillez dans un laboratoire de spectroscopie et vous êtes en train de réaliser une analyse des transitions électroniques d'un échantillon. \n
+  Vous avez utilisé un spectromètre pour mesurer les longueurs d'onde des raies d'émission de la lumière émise par l'échantillon. \n
+  Les mesures que vous avez obtenues sont les suivantes :
+  - Longueur d'onde de la lumière bleue : $\\lambda_{bleue} = ${wavelengthBlueNm}\\ nm$,
+  - Longueur d'onde de la lumière verte : $\\lambda_{verte} = ${wavelengthGreenNm}\\ nm$,
+  - Longueur d'onde de la lumière rouge : $\\lambda_{rouge} = ${wavelengthRedNm}\\ nm$.
+  ![](${images[(0, randint_1.randint)(0, images.length)]})
+  En utilisant ces données, calculez l'énergie de transition en joules pour la lumière ${targetColor} émise par l'échantillon.`;
+    const hint = `Rappelez-vous la relation entre l'énergie et la longueur d'onde : $E = \\frac{hc}{\\lambda}$. Rappel des constantes : 
+  - Constante de Planck : $h = ${h.toSignificant(2).toTex()}$
+  - Vitesse de la lumière : $c = ${c.toSignificant(2).toTex()}$`;
+    const correction = `La relation entre l'énergie et la longueur d'onde est donnée par :
+  $E = \\frac{hc}{\\lambda}$. En utilisant les valeurs fournies pour $h$, $c$, et $\\lambda_{${targetColor}}$ (en mètres), vous pouvez résoudre pour l'énergie :
+  $E_{${targetColor}} = \\frac{${h.toTex({ scientific: 2 })} \\times ${c.toTex({
+        scientific: 2,
+    })}}{${targetColor === "bleue"
+        ? wavelengthBlue.toTex({
+            scientific: 2,
+        })
+        : targetColor === "rouge"
+            ? wavelengthRed.toTex({ scientific: 2 })
+            : wavelengthGreen.toTex({ scientific: 2 })}} = ${targetEnergy.toTex()}\\ J$.`;
+    const question = {
+        answer: targetEnergy.toTex(),
+        instruction,
+        hint,
+        correction,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: {
+            wavelengths: [wavelengthBlue, wavelengthGreen, wavelengthRed],
+            targetColor,
+            energy: targetEnergy,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, energy }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const incorrectValues = [
+        new measure_1.Measure((0, randfloat_1.randfloat)(0.1, 10, 2), -19).toSignificant(2),
+        energy.times(new measure_1.Measure(1, -8)),
+        energy.times(new measure_1.Measure(1, 34)),
+    ];
+    incorrectValues.forEach((value) => {
+        (0, exercise_1.tryToAddWrongProp)(propositions, value.toTex());
+    });
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, new measure_1.Measure((0, randfloat_1.randfloat)(0.1, 10, 2), -19).toSignificant(2).toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, energy, wavelengths, targetColor }) => {
+    const energies = {
+        bleue: h.times(c).divide(wavelengths[0]),
+        verte: h.times(c).divide(wavelengths[1]),
+        rouge: h.times(c).divide(wavelengths[2]),
+    };
+    const targetEnergy = energies[targetColor];
+    const validAnswer1 = targetEnergy.toSignificant(1).toTex();
+    const validAnswer2 = targetEnergy.toSignificant(2).toTex();
+    const validAnswer3 = targetEnergy.toSignificant(3).toTex();
+    let latexs = [];
+    latexs.push(validAnswer1, validAnswer2, validAnswer3);
+    return latexs.includes(ans);
+};
+exports.SpectralEnergyExercise = {
+    id: "spectralEnergy",
+    label: "Calculer l'énergie d'une lumière à partir de la longueur d'onde",
+    levels: ["TermSpé"],
+    isSingleStep: true,
+    sections: ["Quantique"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSpectralEnergyQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

package/lib/index.d.ts

@@ -1617,6 +1617,17 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     epsilon: number;
     l: number;
+}> | import("./exercises/exercise").Exercise<{
+    moleculeName: string;
+    concentration: number;
+    molarAbsorptivity: number;
+    pathLength: number;
+    absorbance: number;
+    randomIndex: number;
+}> | import("./exercises/exercise").Exercise<{
+    wavelengths: import("./pc/measure/measure").Measure[];
+    targetColor: "rouge" | "verte" | "bleue";
+    energy: import("./pc/measure/measure").Measure;
 }>)[];
 export { mathExercises, pcExercises };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

package/lib/pc/constants/quantic.d.ts

@@ -0,0 +1,9 @@
+import { Measure } from "../measure/measure";
+type PhysicalConstant = {
+    value: Measure;
+    unit: string;
+};
+export declare const planckConstant: PhysicalConstant;
+export declare const lightSpeed: PhysicalConstant;
+export {};
+//# sourceMappingURL=quantic.d.ts.map

package/lib/pc/constants/quantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantic.d.ts","sourceRoot":"","sources":["../../../src/pc/constants/quantic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,KAAK,gBAAgB,GAAG;IACtB,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,gBAI5B,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,gBAIxB,CAAC"}

package/lib/pc/constants/quantic.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lightSpeed = exports.planckConstant = void 0;
+const measure_1 = require("../measure/measure");
+exports.planckConstant = {
+    value: new measure_1.Measure(6.626, -34),
+    // value: 6.626 * Math.pow(10, -34),
+    unit: "\\text{J.s}",
+};
+exports.lightSpeed = {
+    value: new measure_1.Measure(3, 8),
+    // value: 3 * Math.pow(10, 8),
+    unit: "\\text{m.s^(-1)}",
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.1.26-beta.2",
+  "version": "2.1.26-beta.3",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [