math-exercises 2.1.26 → 2.2.0

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;AAwJF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAaxD,CAAC"}

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

@@ -0,0 +1,129 @@
+"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 = `La relation entre l'énergie et la longueur d'onde est : $E = \\frac{hc}{\\lambda}$. \n 
+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}$. 
+  
+  \n En utilisant les valeurs fournies pour $h$, $c$, et $\\lambda_{${targetColor}}$ (en mètres), vous pouvez résoudre pour l'énergie : \n 
+  $E_{${targetColor}} = \\dfrac{${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$. \n
+
+  Rappel des constantes : 
+
+  - Constante de Planck : $h = ${h.toSignificant(2).toTex()}$
+  - Vitesse de la lumière : $c = ${c.toSignificant(2).toTex()}$`;
+    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/exercises/utils/geogebra/getPointFromGGB.d.ts

@@ -0,0 +1,3 @@
+import { Point } from "../../../math/geometry/point";
+export declare function getPointFromGGB(command: string, name: string, isInteger?: boolean): Point;
+//# sourceMappingURL=getPointFromGGB.d.ts.map

package/lib/exercises/utils/geogebra/getPointFromGGB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPointFromGGB.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/getPointFromGGB.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAElD,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,OAAc,GACxB,KAAK,CASP"}

package/lib/exercises/utils/geogebra/getPointFromGGB.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPointFromGGB = void 0;
+const point_1 = require("../../../math/geometry/point");
+function getPointFromGGB(command, name, isInteger = true) {
+    const splitted = command.split(",");
+    const x = isInteger
+        ? +(+splitted[0].replace("(", "")).toFixed(0)
+        : +splitted[0].replace("(", "");
+    const y = isInteger
+        ? +(+splitted[1].replace(")", "")).toFixed(0)
+        : +splitted[1].replace(")", "");
+    return new point_1.Point(name, x.toTree(), y.toTree());
+}
+exports.getPointFromGGB = getPointFromGGB;

package/lib/exercises/utils/geogebra/getVectorFromGGB.d.ts

@@ -0,0 +1,3 @@
+import { Vector } from "../../../math/geometry/vector";
+export declare function getVectorFromGGB(command: string, name: string): Vector;
+//# sourceMappingURL=getVectorFromGGB.d.ts.map

package/lib/exercises/utils/geogebra/getVectorFromGGB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getVectorFromGGB.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/getVectorFromGGB.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEpD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKtE"}

package/lib/exercises/utils/geogebra/getVectorFromGGB.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVectorFromGGB = void 0;
+const vector_1 = require("../../../math/geometry/vector");
+function getVectorFromGGB(command, name) {
+    const splitted = command.split(";");
+    const x = +splitted[0].replace("(", "");
+    const y = +splitted[1].replace(")", "");
+    return new vector_1.Vector(name, x.toTree(), y.toTree());
+}
+exports.getVectorFromGGB = getVectorFromGGB;

package/lib/exercises/utils/geogebra/isGGBLine.d.ts

@@ -0,0 +1,2 @@
+export declare function isGGBLine(command: string): boolean;
+//# sourceMappingURL=isGGBLine.d.ts.map

package/lib/exercises/utils/geogebra/isGGBLine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isGGBLine.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/isGGBLine.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGlD"}

package/lib/exercises/utils/geogebra/isGGBLine.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGGBLine = void 0;
+function isGGBLine(command) {
+    const regex = /Line\[[A-Z],\s[A-Z]\]/;
+    return regex.test(command);
+}
+exports.isGGBLine = isGGBLine;

package/lib/exercises/utils/geogebra/isGGBPoint.d.ts

@@ -0,0 +1,2 @@
+export declare function isGGBPoint(command: string): boolean;
+//# sourceMappingURL=isGGBPoint.d.ts.map

package/lib/exercises/utils/geogebra/isGGBPoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isGGBPoint.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/isGGBPoint.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGnD"}

package/lib/exercises/utils/geogebra/isGGBPoint.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGGBPoint = void 0;
+function isGGBPoint(command) {
+    const regex = /\(-?\d+(\.\d+)?\,-?\d+(\.\d+)?\)/;
+    return regex.test(command);
+}
+exports.isGGBPoint = isGGBPoint;

package/lib/exercises/utils/geogebra/toolBarConstructor.d.ts

@@ -0,0 +1,9 @@
+export declare const toolBarConstructor: (options: {
+    point?: boolean;
+    join?: boolean;
+    parallel?: boolean;
+    orthogonal?: boolean;
+    intersect?: boolean;
+    vector?: boolean;
+}) => string;
+//# sourceMappingURL=toolBarConstructor.d.ts.map

package/lib/exercises/utils/geogebra/toolBarConstructor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolBarConstructor.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toolBarConstructor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,YAAa;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,WASA,CAAC"}

package/lib/exercises/utils/geogebra/toolBarConstructor.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolBarConstructor = void 0;
+const toolBarConstructor = (options) => {
+    let customToolBar = "0||6";
+    if (options.point)
+        customToolBar += "||1";
+    if (options.join)
+        customToolBar += "||2";
+    if (options.parallel)
+        customToolBar += "||3";
+    if (options.orthogonal)
+        customToolBar += "||4";
+    if (options.intersect)
+        customToolBar += "||5";
+    if (options.vector)
+        customToolBar += "||7";
+    return customToolBar;
+};
+exports.toolBarConstructor = toolBarConstructor;

package/lib/index.d.ts

@@ -128,6 +128,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     precisionAsked: number;
     decimal: number;
     precision: number;
+}> | import("./exercises/exercise").Exercise<{
+    nb: number;
+    rankAsked: number;
+}> | import("./exercises/exercise").Exercise<{
+    nb: string;
+    rankAsked: number;
 }> | import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
@@ -782,6 +788,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     xValue: number;
     yValue: number;
 }> | import("./exercises/exercise").Exercise<{
+    correctA: number;
+    correctB: number;
+}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
     coin: boolean;
     radius: number;
     diametre: number;
@@ -889,6 +898,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     uY: number;
     aX: number;
     aY: number;
+}> | import("./exercises/exercise").Exercise<{
+    x: number;
+    y: number;
 }> | import("./exercises/exercise").Exercise<{
     trinom: number[];
 }> | import("./exercises/exercise").Exercise<{
@@ -1611,6 +1623,20 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     power: number;
     seconds: number;
+}> | 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/math/numbers/decimals/decimal.d.ts

@@ -3,6 +3,7 @@ import { PercentNode } from "../../../tree/nodes/numbers/percentNode";
 import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode";
 import { Nombre, NumberType } from "../nombre";
 import { Rational } from "../rationals/rational";
+export declare const decimalDigitRanks: string[];
 export declare abstract class DecimalConstructor {
     static randomFracPart(precision: number, leadingZeros?: number): string;
     static random(min: number, max: number, precision?: number): Decimal;

package/lib/math/numbers/decimals/decimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAEvE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAY1E,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAMpE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IAK/D,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;CAMrD;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,aAAsB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;gBACR,KAAK,EAAE,MAAM,GAAG,MAAM;IASlC,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAkClC,gBAAgB;IA6BhB,oBAAoB,CAAC,QAAQ,CAAC,EAAE,MAAM;IAwCtC,UAAU;IAMV,MAAM;IAIN,aAAa;CAGd"}
+{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAEvE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,eAAO,MAAM,iBAAiB,UAAyC,CAAC;AACxE,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAY1E,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAMpE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IAK/D,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;CAMrD;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,aAAsB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;gBACR,KAAK,EAAE,MAAM,GAAG,MAAM;IASlC,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAkClC,gBAAgB;IA6BhB,oBAAoB,CAAC,QAAQ,CAAC,EAAE,MAAM;IAwCtC,UAAU;IAMV,MAAM;IAIN,aAAa;CAGd"}

package/lib/math/numbers/decimals/decimal.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Decimal = exports.DecimalConstructor = void 0;
+exports.Decimal = exports.DecimalConstructor = exports.decimalDigitRanks = void 0;
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
 const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
@@ -9,6 +9,7 @@ const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
 const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
 const nombre_1 = require("../nombre");
 const rational_1 = require("../rationals/rational");
+exports.decimalDigitRanks = ["dixièmes", "centièmes", "millièmes"];
 class DecimalConstructor {
     static randomFracPart(precision, leadingZeros = 0) {
         let decimals = "";

package/lib/math/numbers/integer/integer.d.ts

@@ -1,6 +1,7 @@
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode";
 import { Nombre, NumberType } from "../nombre";
 import { Rational } from "../rationals/rational";
+export declare const integerDigitRanks: string[];
 export declare abstract class IntegerConstructor {
     static random(nbOfDigits: number, excludes?: number[]): number;
     static randomPrime(max?: number): number;

package/lib/math/numbers/integer/integer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/integer/integer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrD,MAAM,CAAC,WAAW,CAAC,GAAG,GAAE,MAAW;IAGnC,MAAM,CAAC,gBAAgB,CACrB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,QAAQ,CAAC,EAAE,MAAM,EAAE;CAYtB;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBAEL,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAMvC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM;IAIN,KAAK,CAAC,SAAS,EAAE,MAAM;IAkCvB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAc1B,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAYxC,QAAQ;IAGR,GAAG,CAAC,EAAE,EAAE,MAAM;CAYf"}
+{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/integer/integer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD,eAAO,MAAM,iBAAiB,UAK7B,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrD,MAAM,CAAC,WAAW,CAAC,GAAG,GAAE,MAAW;IAGnC,MAAM,CAAC,gBAAgB,CACrB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,QAAQ,CAAC,EAAE,MAAM,EAAE;CAYtB;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBAEL,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAMvC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM;IAIN,KAAK,CAAC,SAAS,EAAE,MAAM;IAkCvB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAc1B,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAYxC,QAAQ;IAGR,GAAG,CAAC,EAAE,EAAE,MAAM;CAYf"}

package/lib/math/numbers/integer/integer.js

@@ -1,12 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Integer = exports.IntegerConstructor = void 0;
+exports.Integer = exports.IntegerConstructor = exports.integerDigitRanks = void 0;
 const randint_1 = require("../../../math/utils/random/randint");
 const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const random_1 = require("../../../utils/random");
 const nombre_1 = require("../nombre");
 const rational_1 = require("../rationals/rational");
 const primes_1 = require("./primes");
+exports.integerDigitRanks = [
+    "unités",
+    "dizaines",
+    "centaines",
+    "milliers",
+];
 class IntegerConstructor {
     static random(nbOfDigits, excludes) {
         return (0, randint_1.randint)(10 ** (nbOfDigits - 1), 10 ** nbOfDigits, excludes);

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/lib/server.js

@@ -35,7 +35,9 @@ const dotenv_1 = __importDefault(require("dotenv"));
 const cors_1 = __importDefault(require("cors"));
 const numberNode_1 = require("./tree/nodes/numbers/numberNode");
 const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
+const multiplyNode_1 = require("./tree/nodes/operators/multiplyNode");
 const toScientific_1 = require("./utils/numberPrototype/toScientific");
+const variableNode_1 = require("./tree/nodes/variables/variableNode");
 const jsonParser = body_parser_1.default.json();
 const mathExercises = Object.values(MathExercises);
 const pcExercises = Object.values(PCExercises);
@@ -60,16 +62,10 @@ const runServer = () => {
     app.use((0, cors_1.default)());
     console.log("math exos", mathExercises.length);
     console.log("pc exos", pcExercises.length);
-    // const node = new MultiplyNode(
-    //   (4).toTree(),
-    //   new CosNode(
-    //     new MultiplyNode(
-    //       new FractionNode(new MultiplyNode((2).toTree(), PiNode), (3).toTree()),
-    //       new VariableNode("x"),
-    //     ),
-    //   ),
-    // ).simplify();
-    // console.log(node);
+    const node = new multiplyNode_1.MultiplyNode(new variableNode_1.VariableNode("x"), new variableNode_1.VariableNode("x"))
+        .simplify()
+        .toTex();
+    console.log(node);
     app.get("/", (req, res) => {
         res.json(allExercises);
     });
@@ -130,6 +126,24 @@ const runServer = () => {
             result,
         });
     });
+    app.post("/ggbvea", jsonParser, (req, res) => {
+        const exoId = req.query.exoId;
+        const { ggbAns, ggbVeaProps } = req.body;
+        const exoIndex = allExercises.findIndex((exo) => exo.id == exoId);
+        const exo = allExercises[exoIndex];
+        if (!exo) {
+            res.send("Exo not found");
+            return;
+        }
+        if (!exo.isGGBAnswerValid) {
+            res.send("No GGBVEA implemented");
+            return;
+        }
+        const result = exo.isGGBAnswerValid(ggbAns, ggbVeaProps) ?? false;
+        res.json({
+            result,
+        });
+    });
     app.listen("5000", () => {
         console.log(`[server]: Server is running at http://localhost:5000`);
     });

package/lib/utils/arrayEqual.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arrayEqual.d.ts","sourceRoot":"","sources":["../../src/utils/arrayEqual.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,OAAO,CAO3D"}
+{"version":3,"file":"arrayEqual.d.ts","sourceRoot":"","sources":["../../src/utils/arrayEqual.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,OAAO,CAM3D"}

package/lib/utils/arrayHasSameElement.d.ts

@@ -0,0 +1,2 @@
+export declare function arrayHasSameElements<E>(arr1: E[], arr2: E[]): boolean;
+//# sourceMappingURL=arrayHasSameElement.d.ts.map

package/lib/utils/arrayHasSameElement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayHasSameElement.d.ts","sourceRoot":"","sources":["../../src/utils/arrayHasSameElement.ts"],"names":[],"mappings":"AAAA,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,OAAO,CAKrE"}

package/lib/utils/arrayHasSameElement.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayHasSameElements = void 0;
+function arrayHasSameElements(arr1, arr2) {
+    return (arr1.length === arr2.length &&
+        arr1.every((element) => arr2.includes(element)));
+}
+exports.arrayHasSameElements = arrayHasSameElements;

package/package.json

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