math-exercises 2.0.38 → 2.0.40

package/lib/exercises/conversion/hoursToDecimal.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    dec: number;
+    isDecimalToHours: boolean;
+};
+export declare const hoursToDecimal: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=hoursToDecimal.d.ts.map

package/lib/exercises/conversion/hoursToDecimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hoursToDecimal.d.ts","sourceRoot":"","sources":["../../../src/exercises/conversion/hoursToDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAwEF,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,WAAW,CAapD,CAAC"}

package/lib/exercises/conversion/hoursToDecimal.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hoursToDecimal = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const decimal_1 = require("../../math/numbers/decimals/decimal");
+const randint_1 = require("../../math/utils/random/randint");
+const round_1 = require("../../math/utils/round");
+const coinFlip_1 = require("../../utils/coinFlip");
+const getHoursToDecimalQuestion = () => {
+    const isDecimalToHours = (0, coinFlip_1.coinFlip)();
+    const dec = decimal_1.DecimalConstructor.random(0, 3, 2);
+    const hours = Math.floor(dec.value);
+    const mins = (0, round_1.round)((dec.value - hours) * 100 * 0.6, 0);
+    const decTex = dec.toTree().toTex();
+    const durationTex = isDecimalToHours
+        ? decTex + "\\text{h}"
+        : `${hours}\\text{h}${mins}\\text{min}`;
+    const answer = isDecimalToHours
+        ? `${hours}\\text{h}${mins}\\text{min}`
+        : `${hours},${(0, round_1.round)((mins / 60) * 100, 0)}\\text{h}`;
+    const question = {
+        answer,
+        instruction: `Convertir la durée suivante en ${isDecimalToHours ? "heures et minutes" : "nombre décimal"} : $${durationTex}$ (arrondir ${isDecimalToHours ? "à la minute près" : "au centième près"})`,
+        keys: ["hours", "minutes"],
+        answerFormat: "tex",
+        identifiers: { isDecimalToHours, dec: dec.value },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, isDecimalToHours, dec }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const hours = Math.floor(dec);
+    const mins = (0, round_1.round)((dec - hours) * 0.6 * 100, 0);
+    if (isDecimalToHours) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `${hours}\\text{h}${(0, round_1.round)((dec - hours) * 100, 0)}\\text{min}`);
+        while (propositions.length < n) {
+            (0, exercise_1.tryToAddWrongProp)(propositions, `${hours}\\text{h}${(0, randint_1.randint)(1, 100)}\\text{min}`);
+        }
+    }
+    else {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `${hours},${mins}\\text{h}`);
+        while (propositions.length < n) {
+            (0, exercise_1.tryToAddWrongProp)(propositions, decimal_1.DecimalConstructor.random(hours, hours + 1, 2)
+                .toTree()
+                .toTex() + "\\text{h}");
+        }
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, isDecimalToHours, dec }) => {
+    if (isDecimalToHours)
+        return ans === answer;
+    // const hours = Math.floor(dec);
+    // const mins = round((dec - hours) * 100 * 0.6, 0);
+    const texs = [answer, answer.replace("\\text{h}", "")];
+    return texs.includes(ans);
+};
+exports.hoursToDecimal = {
+    id: "hoursToDecimal",
+    connector: "=",
+    label: "Convertir une durée en nombre décimal et inversement",
+    levels: ["2nde", "2ndPro", "3ème"],
+    isSingleStep: true,
+    sections: ["Conversions"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getHoursToDecimalQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

@@ -4,4 +4,5 @@ export * from "./lengthConversion";
 export * from "./massConversion";
 export * from "./volumeCapacityConversion";
 export * from "./volumeConversion";
+export * from "./hoursToDecimal";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/conversion/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/conversion/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC"}

package/lib/exercises/conversion/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./lengthConversion"), exports);
 __exportStar(require("./massConversion"), exports);
 __exportStar(require("./volumeCapacityConversion"), exports);
 __exportStar(require("./volumeConversion"), exports);
+__exportStar(require("./hoursToDecimal"), exports);

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

@@ -6,4 +6,5 @@ export * from "./rationalFraction";
 export * from "./trinoms";
 export * from "./exponential";
 export * from "./logarithm";
+export * from "./parity";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,oBAAoB,CAAC;AACnC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,oBAAoB,CAAC;AACnC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC"}

package/lib/exercises/functions/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./rationalFraction"), exports);
 __exportStar(require("./trinoms"), exports);
 __exportStar(require("./exponential"), exports);
 __exportStar(require("./logarithm"), exports);
+__exportStar(require("./parity"), exports);

package/lib/exercises/functions/parity/index.d.ts

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

package/lib/exercises/functions/parity/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/parity/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC"}

package/lib/exercises/functions/parity/index.js

@@ -0,0 +1,18 @@
+"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("./parityFromAlgebra"), exports);
+__exportStar(require("./parityFromGraph"), exports);

package/lib/exercises/functions/parity/parityFromAlgebra.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    type: string;
+    fctTex: string;
+};
+export declare const parityFromAlgebra: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=parityFromAlgebra.d.ts.map

package/lib/exercises/functions/parity/parityFromAlgebra.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parityFromAlgebra.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/parity/parityFromAlgebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAoGF,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CAavD,CAAC"}

package/lib/exercises/functions/parity/parityFromAlgebra.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parityFromAlgebra = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const affine_1 = require("../../../math/polynomials/affine");
+const polynomial_1 = require("../../../math/polynomials/polynomial");
+const rationalFrac_1 = require("../../../math/polynomials/rationalFrac");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const randint_1 = require("../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const doWhile_1 = require("../../../utils/doWhile");
+const probaFlip_1 = require("../../../utils/probaFlip");
+const probaLawFlip_1 = require("../../../utils/probaLawFlip");
+const getParityFromAlgebraQuestion = () => {
+    //paires : ax^2 + b   , frac ratio trinom/tirnom
+    //impaires : linéaires, ax^3, linéaire/trinom
+    // ni l'un ni l'autre : affines, trinomes avec ax, x^3 + b
+    const type = (0, probaLawFlip_1.probaLawFlip)([
+        ["even", 0.33],
+        ["uneven", 0.33],
+        ["neither", 0.33],
+    ]);
+    let fct;
+    let answer = "";
+    switch (type) {
+        case "even":
+            if ((0, coinFlip_1.coinFlip)()) {
+                fct = new trinom_1.Trinom((0, randint_1.randint)(-9, 10, [0]), 0, (0, randint_1.randint)(-9, 10))
+                    .toTree()
+                    .toTex();
+            }
+            else {
+                let num = new trinom_1.Trinom((0, randint_1.randint)(-9, 10, [0]), 0, (0, randint_1.randint)(-9, 10));
+                let denum = (0, doWhile_1.doWhile)(() => new trinom_1.Trinom((0, randint_1.randint)(-9, 10, [0]), 0, (0, randint_1.randint)(-9, 10)), (P) => (num.c === 0 ? P.c !== 0 : P.a / num.a === P.c / num.c));
+                fct = new rationalFrac_1.RationalFrac(num, denum).toTree().toTex();
+            }
+            answer = "Paire";
+            break;
+        case "uneven":
+            if ((0, probaFlip_1.probaFlip)(0.33)) {
+                fct = new affine_1.Affine((0, randint_1.randint)(-10, 11, [0]), 0).toTree().toTex();
+            }
+            else {
+                if ((0, coinFlip_1.coinFlip)()) {
+                    fct = new polynomial_1.Polynomial([0, (0, randint_1.randint)(-10, 11), 0, (0, randint_1.randint)(-10, 11, [0])])
+                        .toTree()
+                        .toTex();
+                }
+                else {
+                    let num = new affine_1.Affine((0, randint_1.randint)(-9, 10, [0]), 0);
+                    let denum = new trinom_1.Trinom((0, randint_1.randint)(-9, 10, [0]), 0, (0, randint_1.randint)(-9, 10, [0]));
+                    fct = new rationalFrac_1.RationalFrac(num, denum).toTree().toTex();
+                }
+            }
+            answer = "Impaire";
+            break;
+        case "neither":
+            if ((0, probaFlip_1.probaFlip)(0.33)) {
+                fct = new affine_1.Affine((0, randint_1.randint)(-9, 10, [0]), (0, randint_1.randint)(-9, 10, [0]))
+                    .toTree()
+                    .toTex();
+            }
+            else {
+                if ((0, coinFlip_1.coinFlip)()) {
+                    fct = new trinom_1.Trinom((0, randint_1.randint)(-9, 10, [0]), (0, randint_1.randint)(-9, 10, [0]), (0, randint_1.randint)(-9, 10))
+                        .toTree()
+                        .toTex();
+                }
+                else {
+                    fct = new polynomial_1.Polynomial([
+                        (0, randint_1.randint)(-9, 10),
+                        (0, randint_1.randint)(-9, 10),
+                        (0, randint_1.randint)(-9, 10, [0]),
+                        (0, randint_1.randint)(-9, 10, [0]),
+                    ])
+                        .toTree()
+                        .toTex();
+                }
+            }
+            answer = "Ni paire, ni impaire";
+            break;
+    }
+    const question = {
+        answer,
+        instruction: `Soit $f(x) = ${fct}$. La fonction $f$ est-elle paire, impaire, ou ni paire ni impaire ?`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { type, fctTex: fct },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Paire", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Impaire", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Ni paire ni impaire", "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.parityFromAlgebra = {
+    id: "parityFromAlgebra",
+    label: "Déterminer algébriquement la parité d'une fonction",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Fonctions"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getParityFromAlgebraQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    answerType: "QCM",
+};

package/lib/exercises/functions/parity/parityFromGraph.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    type: string;
+    fctCmd: string;
+};
+export declare const parityFromGraph: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=parityFromGraph.d.ts.map

package/lib/exercises/functions/parity/parityFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parityFromGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/parity/parityFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA4GF,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,WAAW,CAcrD,CAAC"}

package/lib/exercises/functions/parity/parityFromGraph.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parityFromGraph = 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 affine_1 = require("../../../math/polynomials/affine");
+const polynomial_1 = require("../../../math/polynomials/polynomial");
+const rationalFrac_1 = require("../../../math/polynomials/rationalFrac");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const randint_1 = require("../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const doWhile_1 = require("../../../utils/doWhile");
+const probaFlip_1 = require("../../../utils/probaFlip");
+const probaLawFlip_1 = require("../../../utils/probaLawFlip");
+const getParityFromGraphQuestion = () => {
+    //paires : ax^2 + b   , frac ratio trinom/tirnom
+    //impaires : linéaires, ax^3, linéaire/trinom
+    // ni l'un ni l'autre : affines, trinomes avec ax, x^3 + b
+    const type = (0, probaLawFlip_1.probaLawFlip)([
+        ["even", 0.33],
+        ["uneven", 0.33],
+        ["neither", 0.33],
+    ]);
+    let fct;
+    let answer = "";
+    switch (type) {
+        case "even":
+            if ((0, coinFlip_1.coinFlip)()) {
+                fct = new trinom_1.Trinom((0, randint_1.randint)(-9, 10, [0]), 0, (0, randint_1.randint)(-9, 10))
+                    .toTree()
+                    .toMathString();
+            }
+            else {
+                let num = new trinom_1.Trinom((0, randint_1.randint)(-9, 10, [0]), 0, (0, randint_1.randint)(-9, 10));
+                let denum = (0, doWhile_1.doWhile)(() => new trinom_1.Trinom((0, randint_1.randint)(-9, 10, [0]), 0, (0, randint_1.randint)(-9, 10)), (P) => (num.c === 0 ? P.c !== 0 : P.a / num.a === P.c / num.c));
+                fct = new rationalFrac_1.RationalFrac(num, denum).toTree().toMathString();
+            }
+            answer = "Paire";
+            break;
+        case "uneven":
+            if ((0, probaFlip_1.probaFlip)(0.33)) {
+                fct = new affine_1.Affine((0, randint_1.randint)(-10, 11, [0]), 0).toTree().toMathString();
+            }
+            else {
+                if ((0, coinFlip_1.coinFlip)()) {
+                    fct = new polynomial_1.Polynomial([0, (0, randint_1.randint)(-10, 11), 0, (0, randint_1.randint)(-10, 11, [0])])
+                        .toTree()
+                        .toMathString();
+                }
+                else {
+                    let num = new affine_1.Affine((0, randint_1.randint)(-9, 10, [0]), 0);
+                    let denum = new trinom_1.Trinom((0, randint_1.randint)(-9, 10, [0]), 0, (0, randint_1.randint)(-9, 10, [0]));
+                    fct = new rationalFrac_1.RationalFrac(num, denum).toTree().toMathString();
+                }
+            }
+            answer = "Impaire";
+            break;
+        case "neither":
+            if ((0, probaFlip_1.probaFlip)(0.33)) {
+                fct = new affine_1.Affine((0, randint_1.randint)(-9, 10, [0]), (0, randint_1.randint)(-9, 10, [0]))
+                    .toTree()
+                    .toMathString();
+            }
+            else {
+                if ((0, coinFlip_1.coinFlip)()) {
+                    fct = new trinom_1.Trinom((0, randint_1.randint)(-9, 10, [0]), (0, randint_1.randint)(-9, 10, [0]), (0, randint_1.randint)(-9, 10))
+                        .toTree()
+                        .toMathString();
+                }
+                else {
+                    fct = new polynomial_1.Polynomial([
+                        (0, randint_1.randint)(-9, 10),
+                        (0, randint_1.randint)(-9, 10),
+                        (0, randint_1.randint)(-9, 10, [0]),
+                        (0, randint_1.randint)(-9, 10, [0]),
+                    ])
+                        .toTree()
+                        .toMathString();
+                }
+            }
+            answer = "Ni paire, ni impaire";
+            break;
+    }
+    const commands = [`f(x) = ${fct}`, `SetColor(f, "${(0, colors_1.randomColor)()}")`];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isGridSimple: true,
+        isAxesRatioFixed: false,
+    });
+    const question = {
+        answer,
+        instruction: `La fonction $f$ représentée ci-dessous est-elle paire, impaire, ou ni paire ni impaire ?`,
+        keys: [],
+        options: ggb.getOptions(),
+        commands: ggb.commands,
+        coords: [-10, 10, -10, 10],
+        answerFormat: "tex",
+        identifiers: { type, fctCmd: fct },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Paire", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Impaire", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Ni paire ni impaire", "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.parityFromGraph = {
+    id: "parityFromGraph",
+    label: "Reconnaître graphiquement la parité d'une fonction",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Fonctions"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getParityFromGraphQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    answerType: "QCM",
+    hasGeogebra: true,
+};

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

@@ -3,4 +3,6 @@ export * from "./averageEvolutionRate";
 export * from "./evolutionToCM";
 export * from "./globalPercent";
 export * from "./reciprocalPercentage";
+export * from "./percentToDecimal";
+export * from "./valuePercent";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/percent/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/percent/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC"}

package/lib/exercises/percent/index.js

@@ -19,3 +19,5 @@ __exportStar(require("./averageEvolutionRate"), exports);
 __exportStar(require("./evolutionToCM"), exports);
 __exportStar(require("./globalPercent"), exports);
 __exportStar(require("./reciprocalPercentage"), exports);
+__exportStar(require("./percentToDecimal"), exports);
+__exportStar(require("./valuePercent"), exports);

package/lib/exercises/percent/percentToDecimal.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    isPercentToDecimal: boolean;
+    nb: number;
+};
+export declare const percentToDecimal: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=percentToDecimal.d.ts.map

package/lib/exercises/percent/percentToDecimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"percentToDecimal.d.ts","sourceRoot":"","sources":["../../../src/exercises/percent/percentToDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAiEF,eAAO,MAAM,gBAAgB,EAAE,YAAY,CAAC,WAAW,CAatD,CAAC"}

package/lib/exercises/percent/percentToDecimal.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.percentToDecimal = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const decimal_1 = require("../../math/numbers/decimals/decimal");
+const randint_1 = require("../../math/utils/random/randint");
+const coinFlip_1 = require("../../utils/coinFlip");
+const getPercentToDecimalQuestion = () => {
+    const isPercentToDecimal = (0, coinFlip_1.coinFlip)();
+    const nb = decimal_1.DecimalConstructor.random(0, 2);
+    const tex = nb.toTree().toTex();
+    const percentTex = nb.toPercentNode().toTex();
+    const instru = isPercentToDecimal ? percentTex : tex;
+    const answer = isPercentToDecimal ? tex : percentTex;
+    const question = {
+        answer,
+        instruction: `Ecrire le nombre suivant ${isPercentToDecimal
+            ? "sous forme de nombre décimal"
+            : "sous forme de pourcentage"} : $${instru}$`,
+        keys: ["percent"],
+        answerFormat: "tex",
+        identifiers: { isPercentToDecimal, nb: nb.value },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, isPercentToDecimal, nb }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const dec = new decimal_1.Decimal(nb);
+    while (propositions.length < n) {
+        if (isPercentToDecimal) {
+            (0, exercise_1.tryToAddWrongProp)(propositions, dec
+                .multiplyByPowerOfTen((0, randint_1.randint)(-4, 4, [0, 1]))
+                .toTree()
+                .toTex());
+        }
+        else {
+            (0, exercise_1.tryToAddWrongProp)(propositions, dec
+                .multiplyByPowerOfTen((0, randint_1.randint)(-4, 4, [0, 1]))
+                .toPercentNode()
+                .toTex());
+        }
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, isPercentToDecimal, nb }) => {
+    const dec = new decimal_1.Decimal(nb);
+    if (isPercentToDecimal) {
+        return ans === answer;
+    }
+    else {
+        const texs = dec.toPercentNode().toAllValidTexs();
+        return texs.includes(ans);
+    }
+};
+exports.percentToDecimal = {
+    id: "percentToDecimal",
+    connector: "=",
+    label: "Ecrire un pourcentage sous forme décimal et vice-versa",
+    levels: ["2nde", "2ndPro", "1reESM", "1rePro"],
+    isSingleStep: true,
+    sections: ["Pourcentages"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPercentToDecimalQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/percent/valuePercent.d.ts

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

package/lib/exercises/percent/valuePercent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valuePercent.d.ts","sourceRoot":"","sources":["../../../src/exercises/percent/valuePercent.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAmCF,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,WAAW,CAYlD,CAAC"}

package/lib/exercises/percent/valuePercent.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.valuePercent = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const decimal_1 = require("../../math/numbers/decimals/decimal");
+const randint_1 = require("../../math/utils/random/randint");
+const round_1 = require("../../math/utils/round");
+const getValuePercentQuestion = () => {
+    const percent = (0, randint_1.randint)(1, 100);
+    const nb = (0, randint_1.randint)(1, 100);
+    const ans = (0, round_1.round)((percent * nb) / 100, 2).frenchify();
+    const question = {
+        answer: ans + "",
+        instruction: `Calculer $${percent}\\%$ de $${nb}$.`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { percent, nb },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, percent, nb }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, decimal_1.DecimalConstructor.random(0, 100).toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, percent, nb }) => {
+    return ans === answer;
+};
+exports.valuePercent = {
+    id: "valuePercent",
+    connector: "=",
+    label: "Calculer un pourcentage",
+    levels: ["3ème", "2ndPro", "2nde", "1reESM", "1rePro"],
+    isSingleStep: true,
+    sections: ["Pourcentages"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getValuePercentQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/index.d.ts

@@ -1,6 +1,7 @@
 declare global {
     interface Number {
         toTree: () => AlgebraicNode;
+        frenchify: () => string;
     }
 }
 import { AlgebraicNode } from "./tree/nodes/algebraicNode";
@@ -37,6 +38,23 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
 }> | import("./exercises/exercise").MathExercise<{
     rationalNum: [number, number];
     rationalDenum: [number, number];
+}> | import("./exercises/exercise").MathExercise<{
+    rational: [number, number];
+    rational2: [number, number];
+}> | import("./exercises/exercise").MathExercise<{
+    num: number;
+    denum: number;
+}> | import("./exercises/exercise").MathExercise<{
+    num: number;
+    denum: number;
+    leadingPart: number;
+}> | import("./exercises/exercise").MathExercise<{
+    numbers: number[];
+}> | import("./exercises/exercise").MathExercise<{
+    rand: number;
+    a: number;
+    b: number;
+    c: number;
 }> | import("./exercises/exercise").MathExercise<{
     /**
      * TODO
@@ -70,23 +88,6 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
      * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
     
     */
-    rational: [number, number];
-    rational2: [number, number];
-}> | import("./exercises/exercise").MathExercise<{
-    num: number;
-    denum: number;
-}> | import("./exercises/exercise").MathExercise<{
-    num: number;
-    denum: number;
-    leadingPart: number;
-}> | import("./exercises/exercise").MathExercise<{
-    numbers: number[];
-}> | import("./exercises/exercise").MathExercise<{
-    rand: number;
-    a: number;
-    b: number;
-    c: number;
-}> | import("./exercises/exercise").MathExercise<{
     numbers: number[];
 }> | import("./exercises/exercise").MathExercise<{
     rand: number;
@@ -255,6 +256,38 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     z1: number[];
     z2: number[];
 }> | import("./exercises/exercise").MathExercise<{
+    /**
+     * TODO
+     * Décimal : permettre facilement -0.xxx
+     * Tree shaking export
+     *
+     * VEA:
+     *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
+     *      ->> faire le meme delire que pour les power mais pour les opposite ?
+     *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
+     *  -> faire des nodes pour les Ensembles de nombre
+     *
+     * !-> choses pour lesquelles la v1 ne marchera pas :
+     *  !-- fractions non réduites
+     *  !-- nbs décimaux avec des 0
+     *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
+     * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
+     *
+     * Passer les sqrtNode en tree-iable
+     *
+     *
+     *
+     * !!!à fix :
+     * ! fraction réductible
+     * ! 0,20 au lieu de 0,2
+     * ! moins partout dans fraction
+     * !puissances négatives vers inverse fraction
+     * ! simplification du ln
+     * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
+     *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
+     * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
+    
+    */
     re: number;
     im: number;
 }> | import("./exercises/exercise").MathExercise<{
@@ -292,6 +325,9 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     randomUnitIndex: number;
     randomUnitInstructionIndex: number;
     randomVolume: number;
+}> | import("./exercises/exercise").MathExercise<{
+    dec: number;
+    isDecimalToHours: boolean;
 }> | import("./exercises/exercise").MathExercise<{
     tex: string;
 }> | import("./exercises/exercise").MathExercise<{
@@ -524,38 +560,12 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     signs: number[];
     isLog10: boolean;
 }> | import("./exercises/exercise").MathExercise<{
-    /**
-     * TODO
-     * Décimal : permettre facilement -0.xxx
-     * Tree shaking export
-     *
-     * VEA:
-     *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
-     *      ->> faire le meme delire que pour les power mais pour les opposite ?
-     *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
-     *  -> faire des nodes pour les Ensembles de nombre
-     *
-     * !-> choses pour lesquelles la v1 ne marchera pas :
-     *  !-- fractions non réduites
-     *  !-- nbs décimaux avec des 0
-     *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
-     * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
-     *
-     * Passer les sqrtNode en tree-iable
-     *
-     *
-     *
-     * !!!à fix :
-     * ! fraction réductible
-     * ! 0,20 au lieu de 0,2
-     * ! moins partout dans fraction
-     * !puissances négatives vers inverse fraction
-     * ! simplification du ln
-     * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
-     *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
-     * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
-    
-    */
+    type: string;
+    fctTex: string;
+}> | import("./exercises/exercise").MathExercise<{
+    type: string;
+    fctCmd: string;
+}> | import("./exercises/exercise").MathExercise<{
     coin: boolean;
     radius: number;
     diametre: number;
@@ -623,6 +633,38 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
 }> | import("./exercises/exercise").MathExercise<{
     xu: number;
     yu: number;
+    /**
+     * TODO
+     * Décimal : permettre facilement -0.xxx
+     * Tree shaking export
+     *
+     * VEA:
+     *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
+     *      ->> faire le meme delire que pour les power mais pour les opposite ?
+     *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
+     *  -> faire des nodes pour les Ensembles de nombre
+     *
+     * !-> choses pour lesquelles la v1 ne marchera pas :
+     *  !-- fractions non réduites
+     *  !-- nbs décimaux avec des 0
+     *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
+     * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
+     *
+     * Passer les sqrtNode en tree-iable
+     *
+     *
+     *
+     * !!!à fix :
+     * ! fraction réductible
+     * ! 0,20 au lieu de 0,2
+     * ! moins partout dans fraction
+     * !puissances négatives vers inverse fraction
+     * ! simplification du ln
+     * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
+     *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
+     * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
+    
+    */
     xv: number;
     yv: number;
 }> | import("./exercises/exercise").MathExercise<{
@@ -713,44 +755,19 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     rate: number;
     nbMois: number;
 }> | import("./exercises/exercise").MathExercise<{
-    isFromEvolutionToCM: boolean; /**
-     * TODO
-     * Décimal : permettre facilement -0.xxx
-     * Tree shaking export
-     *
-     * VEA:
-     *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
-     *      ->> faire le meme delire que pour les power mais pour les opposite ?
-     *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
-     *  -> faire des nodes pour les Ensembles de nombre
-     *
-     * !-> choses pour lesquelles la v1 ne marchera pas :
-     *  !-- fractions non réduites
-     *  !-- nbs décimaux avec des 0
-     *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
-     * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
-     *
-     * Passer les sqrtNode en tree-iable
-     *
-     *
-     *
-     * !!!à fix :
-     * ! fraction réductible
-     * ! 0,20 au lieu de 0,2
-     * ! moins partout dans fraction
-     * !puissances négatives vers inverse fraction
-     * ! simplification du ln
-     * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
-     *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
-     * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
-    
-    */
+    isFromEvolutionToCM: boolean;
     evolution: number;
 }> | import("./exercises/exercise").MathExercise<{
     evolutions: string[];
 }> | import("./exercises/exercise").MathExercise<{
     randPercent: number;
     isUp: boolean;
+}> | import("./exercises/exercise").MathExercise<{
+    isPercentToDecimal: boolean;
+    nb: number;
+}> | import("./exercises/exercise").MathExercise<{
+    percent: number;
+    nb: number;
 }> | import("./exercises/exercise").MathExercise<{
     int: number;
     power: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;KAC7B;CACF;AA6CD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAtCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAO4C,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;KACzB;CACF;AAgDD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAtCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAO4C,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/lib/index.js

@@ -34,6 +34,9 @@ Number.prototype.toTree = function () {
         return infiniteNode_1.MinusInfinityNode;
     return new numberNode_1.NumberNode(value);
 };
+Number.prototype.frenchify = function () {
+    return (this.valueOf() + "").replace(".", ",");
+};
 /**
  * TODO
  * Décimal : permettre facilement -0.xxx

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

@@ -1,4 +1,5 @@
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode";
+import { PercentNode } from "../../../tree/nodes/numbers/percentNode";
 import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode";
 import { Nombre, NumberType } from "../nombre";
 import { Rational } from "../rationals/rational";
@@ -28,5 +29,6 @@ export declare class Decimal implements Nombre {
     toScientificNotation(): NumberNode | MultiplyNode;
     toRational(): Rational | import("../integer/integer").Integer;
     toTree(): NumberNode;
+    toPercentNode(): PercentNode;
 }
 //# sourceMappingURL=decimal.d.ts.map

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,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;IASzB,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAkClC,gBAAgB;IA2BhB,oBAAoB;IAsBpB,UAAU;IAMV,MAAM;CAGP"}
+{"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;IASzB,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAkClC,gBAAgB;IA2BhB,oBAAoB;IAsBpB,UAAU;IAMV,MAAM;IAIN,aAAa;CAGd"}

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

@@ -4,6 +4,7 @@ exports.Decimal = exports.DecimalConstructor = 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");
+const percentNode_1 = require("../../../tree/nodes/numbers/percentNode");
 const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
 const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
 const nombre_1 = require("../nombre");
@@ -138,5 +139,8 @@ class Decimal {
     toTree() {
         return new numberNode_1.NumberNode(this.value);
     }
+    toPercentNode() {
+        return new percentNode_1.PercentNode(this.multiplyByPowerOfTen(2).value);
+    }
 }
 exports.Decimal = Decimal;

package/lib/math/polynomials/polynomial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomial.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/polynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAcjE,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAa5D,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IActD;;;;;;OAMG;IACH,MAAM,CAAC,gBAAgB,CACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAoBxB,MAAM,CAAC,4BAA4B,CACjC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAqBxB,MAAM,CAAC,UAAU,CACf,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,UAAU,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,GAAE,MAAY;CAmCzB;AAED,qBAAa,UAAU;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB;;;;OAIG;gBACS,YAAY,EAAE,MAAM,EAAE,EAAE,QAAQ,GAAE,MAAY;IAY1D,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAM9B,QAAQ,IAAI,MAAM,EAAE;IAkCpB,GAAG,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,UAAU;IAyBvC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU;IAQ7B,QAAQ,CAAC,CAAC,EAAE,UAAU,GAAG,UAAU;IAuBnC,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU;IAMnC,QAAQ,IAAI,UAAU;IAOtB,QAAQ,IAAI,UAAU;IAmBtB,eAAe,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BlC,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAO5B,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM;IAiB7C,YAAY,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU;IAiBxC,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW;IAuCzB,KAAK,IAAI,MAAM;IAyBf,QAAQ,IAAI,MAAM;CAGnB"}
+{"version":3,"file":"polynomial.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/polynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAcjE,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAa5D,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IActD;;;;;;OAMG;IACH,MAAM,CAAC,gBAAgB,CACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAoBxB,MAAM,CAAC,4BAA4B,CACjC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAqBxB,MAAM,CAAC,UAAU,CACf,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,UAAU,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,GAAE,MAAY;CAmCzB;AAED,qBAAa,UAAU;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB;;;;OAIG;gBACS,YAAY,EAAE,MAAM,EAAE,EAAE,QAAQ,GAAE,MAAY;IAY1D,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAM9B,QAAQ,IAAI,MAAM,EAAE;IAkCpB,GAAG,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,UAAU;IAyBvC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU;IAQ7B,QAAQ,CAAC,CAAC,EAAE,UAAU,GAAG,UAAU;IAuBnC,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU;IAqBnC,QAAQ,IAAI,UAAU;IAOtB,QAAQ,IAAI,UAAU;IAmBtB,eAAe,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BlC,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAO5B,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM;IAiB7C,YAAY,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU;IAiBxC,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW;IAuCzB,KAAK,IAAI,MAAM;IAyBf,QAAQ,IAAI,MAAM;CAGnB"}

package/lib/math/polynomials/polynomial.js

@@ -213,6 +213,17 @@ class Polynomial {
     scalarDivide(n) {
         return new Polynomial(this.coefficients.map((coeff) => coeff / n), this.variable);
     }
+    // divide(Q: Polynomial): Polynomial {
+    //   function n / d is
+    //   require d ≠ 0
+    //   q ← 0
+    //   r ← n             // At each step n = d × q + r
+    //   while r ≠ 0 and degree(r) ≥ degree(d) do
+    //       t ← lead(r) / lead(d)       // Divide the leading terms
+    //       q ← q + t
+    //       r ← r − t × d
+    //   return (q, r)
+    // }
     opposite() {
         return new Polynomial(this.coefficients.map((coeff) => -coeff), this.variable);
     }

package/lib/math/polynomials/rationalFrac.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rationalFrac.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/rationalFrac.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAEzD,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAGrD,qBAAa,YAAY;IACvB,GAAG,EAAE,UAAU,CAAC;IAChB,KAAK,EAAE,UAAU,CAAC;gBACN,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU;IAI9C,MAAM;IAGN,QAAQ;CAuCT"}
+{"version":3,"file":"rationalFrac.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/rationalFrac.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAEzD,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAGrD,qBAAa,YAAY;IACvB,GAAG,EAAE,UAAU,CAAC;IAChB,KAAK,EAAE,UAAU,CAAC;gBACN,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU;IAI9C,MAAM;IAiBN,QAAQ;CAuCT"}

package/lib/math/polynomials/rationalFrac.js

@@ -14,6 +14,19 @@ class RationalFrac {
     toTree() {
         return new fractionNode_1.FractionNode(this.num.toTree(), this.denum.toTree());
     }
+    // isSimplified(){
+    //   if (this.num.coefficients.length === 1 && this.num.coefficients[0] === 0)
+    //   return true;
+    // const numCoeffs = this.num.coefficients.filter((c) => c !== 0);
+    // const numPGCD = numCoeffs.length > 1 ? gcd(...numCoeffs) : numCoeffs[0];
+    // const denumCoeffs = this.denum.coefficients.filter((c) => c !== 0);
+    // const denumPGCD =
+    //   denumCoeffs.length > 1 ? gcd(...denumCoeffs) : denumCoeffs[0];
+    // const rational = new Rational(numPGCD, denumPGCD);
+    // if (rational.isIrreductible()) {
+    //   return this;
+    // }
+    // }
     simplify() {
         if (this.num.coefficients.length === 1 && this.num.coefficients[0] === 0)
             return new integer_1.Integer(0);

package/lib/server.d.ts

@@ -4,6 +4,7 @@ import { AlgebraicNode } from "./tree/nodes/algebraicNode";
 declare global {
     interface Number {
         toTree: () => AlgebraicNode;
+        frenchify: () => string;
     }
 }
 //# sourceMappingURL=server.d.ts.map

package/lib/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAGzC,OAAO,EAAE,SAAS,EAAE,CAAC;AAarB,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAe3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;KAC7B;CACF"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAGzC,OAAO,EAAE,SAAS,EAAE,CAAC;AAarB,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAgB3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;KACzB;CACF"}

package/lib/server.js

@@ -37,6 +37,7 @@ 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 round_1 = require("./math/utils/round");
 const jsonParser = body_parser_1.default.json();
 const allExercises = [...exercises];
 Number.prototype.toTree = function () {
@@ -47,11 +48,15 @@ Number.prototype.toTree = function () {
         return infiniteNode_1.MinusInfinityNode;
     return new numberNode_1.NumberNode(value);
 };
+Number.prototype.frenchify = function () {
+    return (this.valueOf() + "").replace(".", ",");
+};
 const runServer = () => {
     dotenv_1.default.config();
     const app = (0, express_1.default)();
     app.use((0, cors_1.default)());
     console.log(exercises.length);
+    console.log((0, round_1.round)((35 * 10) / 6, 2) * 100);
     app.get("/", (req, res) => {
         res.json(allExercises);
     });

package/lib/types/keyIds.d.ts

@@ -1,6 +1,6 @@
 export type KeyId = 
 /**units */
-"cm" | "cm2" | "celsius" | "Hz" | "mol" | "kJ" | "mL"
+"cm" | "cm2" | "celsius" | "Hz" | "mol" | "kJ" | "mL" | "minutes" | "hours"
 /**utility */
  | "custom" | "right" | "left" | "rightarrow" | "del" | "close" | "switch" | "maj"
 /**words */

package/lib/types/keyIds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keyIds.d.ts","sourceRoot":"","sources":["../../src/types/keyIds.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"keyIds.d.ts","sourceRoot":"","sources":["../../src/types/keyIds.ts"],"names":[],"mappings":"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"}

package/lib/utils/probaLawFlip.d.ts

@@ -1,2 +1,7 @@
+/**
+ *
+ * @param arr [T, proba]
+ * @returns element T_i with proba p_i
+ */
 export declare const probaLawFlip: <T>(arr: [T, number][]) => T;
 //# sourceMappingURL=probaLawFlip.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"probaLawFlip.d.ts","sourceRoot":"","sources":["../../src/utils/probaLawFlip.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,8BAYxB,CAAC"}
+{"version":3,"file":"probaLawFlip.d.ts","sourceRoot":"","sources":["../../src/utils/probaLawFlip.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,YAAY,8BAaxB,CAAC"}

package/lib/utils/probaLawFlip.js

@@ -1,9 +1,14 @@
 "use strict";
+/**
+ *
+ * @param arr [T, proba]
+ * @returns element T_i with proba p_i
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.probaLawFlip = void 0;
 const probaLawFlip = (arr) => {
     if (Math.abs(arr.reduce((acc, curr) => (acc += curr[1]), 0) - 1) > 0.1)
-        throw Error('proba law does not add up t 1');
+        throw Error("proba law does not add up t 1");
     const rand = Math.random();
     const sorted = [...arr].sort((a, b) => b[1] - a[1]);
     let probaAcc = 0;

package/package.json

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