math-exercises 2.2.37 → 2.2.38

package/lib/exercises/math/conversion/aeraConversion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aeraConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/aeraConversion.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAExB,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA4DF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}
+{"version":3,"file":"aeraConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/aeraConversion.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAExB,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA2DF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}

package/lib/exercises/math/conversion/aeraConversion.js

@@ -36,8 +36,7 @@ const getPropositions = (n, { answer, randomAera, randomUnitIndex, randomUnitIns
     while (propositions.length < n) {
         const wrongAnswer = aeraDecimal
             .multiplyByPowerOfTen(2 * (0, randint_1.randint)(-2, 4, [randomUnitIndex - randomUnitInstructionIndex]))
-            .value.toString()
-            .replace(".", ",");
+            .value.frenchify();
         (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
     }
     return (0, shuffle_1.shuffle)(propositions);

package/lib/exercises/math/functions/basics/imageAntecedentFromSentence.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    isImage: boolean;
+    x: number;
+    y: number;
+};
+export declare const imageAntecedentFromSentence: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=imageAntecedentFromSentence.d.ts.map

package/lib/exercises/math/functions/basics/imageAntecedentFromSentence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageAntecedentFromSentence.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageAntecedentFromSentence.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsEF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAgB7D,CAAC"}

package/lib/exercises/math/functions/basics/imageAntecedentFromSentence.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imageAntecedentFromSentence = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../../utils/alea/coinFlip");
+const getPropositions = (n, { answer, isImage, x, y }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, getAnswer({ isImage, x: y, y: x }));
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${x}=${y}`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, getAnswer({ isImage, x: y, y: y }));
+    // tryToAddWrongProp(propositions, getAnswer({ isImage, x: x, y: x }));
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return `f\\left(${identifiers.x}\\right)=${identifiers.y}`;
+};
+const getInstruction = (identifiers) => {
+    let instruction = "Traduire par une égalité la phrase suivante : \n \n";
+    instruction += identifiers.isImage
+        ? `
+  "L'image de $${identifiers.x}$ par $f$ est $${identifiers.y}$"
+  `
+        : `"Un antécédent de $${identifiers.y}$ par $f$ est $${identifiers.x}$"`;
+    return instruction;
+};
+const getHint = (identifiers) => {
+    return `Si $f(x) = y$, alors $x$ est un antécédent de $y$ par $f$, et $y$ est l'image de $x$ par $f$.`;
+};
+const getCorrection = (identifiers) => {
+    return `Si $f(x) = y$, alors $x$ est un antécédent de $y$ par $f$, et $y$ est l'image de $x$ par $f$. Ici, on a donc $${getAnswer(identifiers)}$`;
+};
+const getKeys = (identifiers) => {
+    return ["fParenthesis", "equal"];
+};
+const isAnswerValid = (ans, { answer, x, y }) => {
+    const reversed = answer.split("=").reverse().join("=");
+    return [answer, reversed].includes(ans);
+};
+const getImageAntecedentFromSentenceQuestion = () => {
+    const x = (0, randint_1.randint)(-10, 10);
+    const y = (0, randint_1.randint)(-10, 10, [x]);
+    const identifiers = {
+        isImage: (0, coinFlip_1.coinFlip)(),
+        x,
+        y,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.imageAntecedentFromSentence = {
+    id: "imageAntecedentFromSentence",
+    connector: "\\iff",
+    label: "Traduire une phrase contenant image ou antécédent en une égalité",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getImageAntecedentFromSentenceQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

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

@@ -7,4 +7,5 @@ export * from "./graphicInequation";
 export * from "./twoFunctionsEquation";
 export * from "./twoFunctionsInequation";
 export * from "./inverseImageFunctionTable";
+export * from "./imageAntecedentFromSentence";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC"}

package/lib/exercises/math/functions/basics/index.js

@@ -23,3 +23,4 @@ __exportStar(require("./graphicInequation"), exports);
 __exportStar(require("./twoFunctionsEquation"), exports);
 __exportStar(require("./twoFunctionsInequation"), exports);
 __exportStar(require("./inverseImageFunctionTable"), exports);
+__exportStar(require("./imageAntecedentFromSentence"), exports);

package/lib/exercises/math/geometry/areas/circleRadiusFromArea.d.ts

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

package/lib/exercises/math/geometry/areas/circleRadiusFromArea.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circleRadiusFromArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/circleRadiusFromArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAyFF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAgBtD,CAAC"}

package/lib/exercises/math/geometry/areas/circleRadiusFromArea.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.circleRadiusFromArea = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const round_1 = require("../../../../math/utils/round");
+const sqrtNode_1 = require("../../../../tree/nodes/functions/sqrtNode");
+const piNode_1 = require("../../../../tree/nodes/numbers/piNode");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
+const numberParser_1 = require("../../../../tree/parsers/numberParser");
+const alignTex_1 = require("../../../../utils/latex/alignTex");
+const getPropositions = (n, { answer, area }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(Math.sqrt(area), 2).frenchify());
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(area / Math.PI, 2).frenchify());
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(area / (2 * Math.PI), 2).frenchify());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(1, 100, 2).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return (0, round_1.round)(Math.sqrt(identifiers.area / Math.PI), 2).frenchify();
+};
+const getInstruction = (identifiers) => {
+    return `Calculer le rayon d'un cercle d'aire $${identifiers.area.frenchify()}$. Arrondir au centième.`;
+};
+const getHint = (identifiers) => {
+    return `L'aire d'un cercle est égale à : 
+    
+$$
+\\pi\\times r^2
+$$
+
+où $r$ est le rayon.`;
+};
+const getCorrection = (identifiers) => {
+    const r2 = identifiers.area / Math.PI;
+    return `L'aire d'un cercle est égale à : 
+    
+$$
+\\pi\\times r^2
+$$
+
+où $r$ est le rayon.
+
+Ici, on a donc : 
+
+$$
+${identifiers.area.frenchify()} =  \\pi\\times r^2
+$$
+
+On isole $r^2$ dans cette équation : 
+
+${(0, alignTex_1.alignTex)([
+        ["r^2", "=", new fractionNode_1.FractionNode(identifiers.area.toTree(), piNode_1.PiNode).toTex()],
+        ["", "\\approx", (0, round_1.round)(r2, 2).frenchify()],
+    ])}
+
+Enfin, on obtient $r$ en prenant la racine carrée du résultat précédent : 
+
+${(0, alignTex_1.alignTex)([
+        ["r", "=", new sqrtNode_1.SqrtNode((0, round_1.round)(r2, 2).toTree()).toTex()],
+        ["", "\\approx", getAnswer(identifiers)],
+    ])}
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, area }) => {
+    const parsed = (0, numberParser_1.numberParser)(ans);
+    if (!parsed)
+        return false;
+    return parsed === answer;
+};
+const getCircleRadiusFromAreaQuestion = () => {
+    const area = (0, randfloat_1.randfloat)(1, 100, 2);
+    const identifiers = { area };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.circleRadiusFromArea = {
+    id: "circleRadiusFromArea",
+    connector: "=",
+    label: "Calculer le rayon d'un cercle en connaissant son aire",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCircleRadiusFromAreaQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/areas/index.d.ts

@@ -4,4 +4,7 @@ export * from "./rightTriangleArea";
 export * from "./squareArea";
 export * from "./triangleArea";
 export * from "./triangleAreaV2";
+export * from "./squareSideFromArea";
+export * from "./rectangleSideFromArea";
+export * from "./circleRadiusFromArea";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/areas/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC"}

package/lib/exercises/math/geometry/areas/index.js

@@ -20,3 +20,6 @@ __exportStar(require("./rightTriangleArea"), exports);
 __exportStar(require("./squareArea"), exports);
 __exportStar(require("./triangleArea"), exports);
 __exportStar(require("./triangleAreaV2"), exports);
+__exportStar(require("./squareSideFromArea"), exports);
+__exportStar(require("./rectangleSideFromArea"), exports);
+__exportStar(require("./circleRadiusFromArea"), exports);

package/lib/exercises/math/geometry/areas/rectangleSideFromArea.d.ts

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

package/lib/exercises/math/geometry/areas/rectangleSideFromArea.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rectangleSideFromArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/rectangleSideFromArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoFF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAiBvD,CAAC"}

package/lib/exercises/math/geometry/areas/rectangleSideFromArea.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rectangleSideFromArea = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const round_1 = require("../../../../math/utils/round");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
+const numberParser_1 = require("../../../../tree/parsers/numberParser");
+const alignTex_1 = require("../../../../utils/latex/alignTex");
+const getPropositions = (n, { answer, area, width }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(area / 4, 3).frenchify());
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(area - width, 3).frenchify());
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)((area - 2 * width) / 2, 3).frenchify());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(1, 100, 2).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return (0, round_1.round)(identifiers.area / identifiers.width, 2).frenchify();
+};
+const getInstruction = (identifiers) => {
+    return `Calculer la longueur d'un rectangle d'aire $${identifiers.area.frenchify()}$ et de largeur $${identifiers.width.frenchify()}$.`;
+};
+const getHint = (identifiers) => {
+    return `L'aire d'un rectangle est le produit de la largeur et de la longueur.`;
+};
+const getCorrection = (identifiers) => {
+    return `L'aire d'un rectangle est le produit de la largeur et de la longueur.
+  
+Ici, on a donc : 
+  
+$$
+${identifiers.area.frenchify()} = ${identifiers.width.frenchify()}\\times L
+$$
+    
+Pour retrouver la longueur, on isole $L$ dans cette équation. On obtient : 
+  
+${(0, alignTex_1.alignTex)([
+        [
+            "L",
+            "=",
+            `${new fractionNode_1.FractionNode(identifiers.area.toTree(), identifiers.width.toTree()).toTex()}`,
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, area, width }) => {
+    const parsed = (0, numberParser_1.numberParser)(ans);
+    if (!parsed)
+        return false;
+    return parsed === answer;
+};
+const getRectangleSideFromAreaQuestion = () => {
+    const width = (0, randfloat_1.randfloat)(1, 50, 1);
+    const length = (0, randfloat_1.randfloat)(width + 1, width + 30, 1);
+    const area = (0, round_1.round)(width * length, 5);
+    const identifiers = {
+        area,
+        width,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.rectangleSideFromArea = {
+    id: "rectangleSideFromArea",
+    connector: "=",
+    label: "Calculer la longueur d'un rectangle en connaissant son aire et sa largeur",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRectangleSideFromAreaQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/areas/squareSideFromArea.d.ts

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

package/lib/exercises/math/geometry/areas/squareSideFromArea.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"squareSideFromArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/squareSideFromArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AA+DF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAgBpD,CAAC"}

package/lib/exercises/math/geometry/areas/squareSideFromArea.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.squareSideFromArea = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const randint_1 = require("../../../../math/utils/random/randint");
+const round_1 = require("../../../../math/utils/round");
+const sqrtNode_1 = require("../../../../tree/nodes/functions/sqrtNode");
+const coinFlip_1 = require("../../../../utils/alea/coinFlip");
+const getPropositions = (n, { answer, area }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, (area * area).frenchify());
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(area / 2, 2).frenchify());
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(area / 4, 2).frenchify());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(1, 100, 2).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return (0, round_1.round)(Math.sqrt(identifiers.area), 2).frenchify();
+};
+const getInstruction = (identifiers) => {
+    return `Calculer le côté d'un carré d'aire $${identifiers.area.frenchify()}$. Arrondir au centième.`;
+};
+const getHint = (identifiers) => {
+    return `L'aire d'un carré est égale au carré du côté.`;
+};
+const getCorrection = (identifiers) => {
+    return `L'aire d'un carré est égale au carré du côté. Pour retrouver le côté à partir de l'aire, il faut donc calculer la racine carrée de l'aire. Le côté du carré est donc égal à : 
+    
+$$
+${new sqrtNode_1.SqrtNode(identifiers.area.toTree()).toTex()}${identifiers.isPerfectSquare ? "=" : "\\approx"}${getAnswer(identifiers)}
+$$
+  `;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, area }) => {
+    const node = new sqrtNode_1.SqrtNode(area.toTree());
+    const approximation = (0, round_1.round)(Math.sqrt(area), 2).frenchify();
+    return [...node.toAllValidTexs(), approximation].includes(ans);
+};
+const getSquareSideFromAreaQuestion = () => {
+    const isPerfectSquare = (0, coinFlip_1.coinFlip)();
+    const area = isPerfectSquare ? (0, randint_1.randint)(1, 11) ** 2 : (0, randfloat_1.randfloat)(1, 100, 1);
+    const identifiers = { area, isPerfectSquare };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.squareSideFromArea = {
+    id: "squareSideFromArea",
+    connector: "=",
+    label: "Calculer le côté d'un carré en connaissant son aire",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSquareSideFromAreaQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/cartesian/readAbscissOnSemiLine.js

@@ -106,7 +106,7 @@ const getReadAbscissOnSemiLineQuestion = () => {
             break;
         case nombre_1.NumberType.Decimal:
         default:
-            axisUnit = (0, randfloat_1.randfloat)(0, 5, 1);
+            axisUnit = (0, randfloat_1.randfloat)(0.1, 5, 1);
             coeff = (0, randint_1.randint)(2, 10);
             absciss = (0, round_1.round)(axisUnit * coeff, 2);
             oneUnitTex = axisUnit.frenchify();

package/lib/exercises/math/geometry/perimeters/circleRadiusFromPerimeter.d.ts

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

package/lib/exercises/math/geometry/perimeters/circleRadiusFromPerimeter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circleRadiusFromPerimeter.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/circleRadiusFromPerimeter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA2FF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAgB3D,CAAC"}

package/lib/exercises/math/geometry/perimeters/circleRadiusFromPerimeter.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.circleRadiusFromPerimeter = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const round_1 = require("../../../../math/utils/round");
+const piNode_1 = require("../../../../tree/nodes/numbers/piNode");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const numberParser_1 = require("../../../../tree/parsers/numberParser");
+const alignTex_1 = require("../../../../utils/latex/alignTex");
+const getPropositions = (n, { answer, perimeter }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(Math.sqrt(perimeter), 2).frenchify());
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(perimeter / Math.PI, 2).frenchify());
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(perimeter / 4, 2).frenchify());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(1, 100, 2).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return (0, round_1.round)(identifiers.perimeter / (2 * Math.PI), 2).frenchify();
+};
+const getInstruction = (identifiers) => {
+    return `Calculer le rayon d'un cercle de périmètre $${identifiers.perimeter.frenchify()}$. Arrondir au centième.`;
+};
+const getHint = (identifiers) => {
+    return `Le périmètre d'un cercle est égale à : 
+      
+  $$
+  2\\times \\pi\\times r
+  $$
+  
+  où $r$ est le rayon.`;
+};
+const getCorrection = (identifiers) => {
+    return `Le périmètre d'un cercle est égal à : 
+      
+  $$
+  2\\times \\pi\\times r
+  $$
+  
+  où $r$ est le rayon.
+  
+  Ici, on a donc : 
+  
+  $${identifiers.perimeter.frenchify()} = 2\\times \\pi\\times r$
+  
+  On isole $r$ dans cette équation : 
+  
+  ${(0, alignTex_1.alignTex)([
+        [
+            "r",
+            "=",
+            new fractionNode_1.FractionNode(identifiers.perimeter.toTree(), new multiplyNode_1.MultiplyNode((2).toTree(), piNode_1.PiNode)).toTex(),
+        ],
+        ["", "\\aprox", getAnswer(identifiers)],
+    ])}
+  `;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, perimeter }) => {
+    const parsed = (0, numberParser_1.numberParser)(ans);
+    if (!parsed)
+        return false;
+    return parsed === answer;
+};
+const getCircleRadiusFromPerimeterQuestion = () => {
+    const perimeter = (0, randfloat_1.randfloat)(1, 100, 2);
+    const identifiers = { perimeter };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.circleRadiusFromPerimeter = {
+    id: "circleRadiusFromPerimeter",
+    connector: "=",
+    label: "Calculer le rayon d'un cercle en connaissant son périmètre",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCircleRadiusFromPerimeterQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/perimeters/index.d.ts

@@ -2,4 +2,7 @@ export * from "./circleCircumference";
 export * from "./rectanglePerimeter";
 export * from "./squarePerimeter";
 export * from "./trianglePerimeter";
+export * from "./squareSideFromPerimeter";
+export * from "./rectangleSideFromPerimeter";
+export * from "./circleRadiusFromPerimeter";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/perimeters/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC"}

package/lib/exercises/math/geometry/perimeters/index.js

@@ -18,3 +18,6 @@ __exportStar(require("./circleCircumference"), exports);
 __exportStar(require("./rectanglePerimeter"), exports);
 __exportStar(require("./squarePerimeter"), exports);
 __exportStar(require("./trianglePerimeter"), exports);
+__exportStar(require("./squareSideFromPerimeter"), exports);
+__exportStar(require("./rectangleSideFromPerimeter"), exports);
+__exportStar(require("./circleRadiusFromPerimeter"), exports);

package/lib/exercises/math/geometry/perimeters/rectangleSideFromPerimeter.d.ts

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

package/lib/exercises/math/geometry/perimeters/rectangleSideFromPerimeter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rectangleSideFromPerimeter.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/rectangleSideFromPerimeter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA4GF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAiB5D,CAAC"}

package/lib/exercises/math/geometry/perimeters/rectangleSideFromPerimeter.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rectangleSideFromPerimeter = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const round_1 = require("../../../../math/utils/round");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
+const alignTex_1 = require("../../../../utils/latex/alignTex");
+const getPropositions = (n, { answer, perimeter, width }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(perimeter / 4, 2).frenchify());
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(perimeter - width, 2).frenchify());
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(perimeter - 2 * width, 2).frenchify());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(1, 100, 2).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return (0, round_1.round)((identifiers.perimeter - 2 * identifiers.width) / 2, 2).frenchify();
+};
+const getInstruction = (identifiers) => {
+    return `Calculer la longueur d'un rectangle de périmètre $${identifiers.perimeter.frenchify()}$ et de largeur $${identifiers.width.frenchify()}$.`;
+};
+const getHint = (identifiers) => {
+    return `Le périmètre d'un rectangle est égal à :
+
+$$
+P = 2\\times l + 2\\times L
+$$
+
+où $l$ et la largeur et $L$ et la longueur.`;
+};
+const getCorrection = (identifiers) => {
+    const lengthDouble = (0, round_1.round)(identifiers.perimeter - 2 * identifiers.width, 3);
+    return `Le périmètre d'un rectangle est égal à :
+
+$$
+P = 2\\times l + 2\\times L
+$$
+
+Ici, on a donc : 
+
+$$
+${identifiers.perimeter.frenchify()} = 2\\times ${identifiers.width.frenchify()} + 2\\times L
+$$
+    
+Pour retrouver la longueur, on isole $L$ dans cette équation. On obtient : 
+
+${(0, alignTex_1.alignTex)([
+        [
+            "2\\times L",
+            "=",
+            `${identifiers.perimeter.frenchify()}- 2\\times ${identifiers.width.frenchify()}`,
+        ],
+        ["", "=", `${lengthDouble.frenchify()}`],
+    ])}
+
+Ainsi, la longueur du rectangle vaut : 
+
+${(0, alignTex_1.alignTex)([
+        [
+            "L",
+            "=",
+            `${new fractionNode_1.FractionNode(lengthDouble.toTree(), (2).toTree()).toTex()}`,
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+  `;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, perimeter, width }) => {
+    const node = new fractionNode_1.FractionNode((perimeter - 2 * width).toTree(), (2).toTree());
+    return node.toAllValidTexs({ allowFractionToDecimal: true }).includes(ans);
+};
+const getRectangleSideFromPerimeterQuestion = () => {
+    const width = (0, randfloat_1.randfloat)(1, 50, 1);
+    const perimeter = (0, randfloat_1.randfloat)(2 * width + 2, 2 * width + 50, 1);
+    const length = (0, round_1.round)((perimeter - 2 * width) / 2, 2);
+    const identifiers = {
+        perimeter,
+        width: Math.min(width, length),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.rectangleSideFromPerimeter = {
+    id: "rectangleSideFromPerimeter",
+    connector: "=",
+    label: "Calculer la longueur d'un rectangle en connaissant son périmètre et sa largeur",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRectangleSideFromPerimeterQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/perimeters/squareSideFromPerimeter.d.ts

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

package/lib/exercises/math/geometry/perimeters/squareSideFromPerimeter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"squareSideFromPerimeter.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/squareSideFromPerimeter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAmEF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAgBzD,CAAC"}

package/lib/exercises/math/geometry/perimeters/squareSideFromPerimeter.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.squareSideFromPerimeter = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const real_1 = require("../../../../math/numbers/reals/real");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const round_1 = require("../../../../math/utils/round");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
+const getPropositions = (n, { answer, perimeter }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, (4 * perimeter).frenchify());
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(perimeter / 2, 3).frenchify());
+    const sqrt = new real_1.SquareRoot(perimeter).basicSimplify().toTree().toTex();
+    (0, exercise_1.tryToAddWrongProp)(propositions, sqrt);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(1, 100, 2).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return (0, round_1.round)(identifiers.perimeter / 4, 3).frenchify();
+};
+const getInstruction = (identifiers) => {
+    return `Calculer le côté d'un carré de périmètre $${identifiers.perimeter.frenchify()}$.`;
+};
+const getHint = (identifiers) => {
+    return `Le périmètre d'un carré est égal à $4$ fois la longueur du côté.`;
+};
+const getCorrection = (identifiers) => {
+    return `Le périmètre d'un carré est égal à $4$ fois la longueur du côté. Pour retrouver le côté à partir du périmètre, il faut donc diviser le périmètre par $4$. Le côté du carré est donc égal à : 
+  
+$$
+${new fractionNode_1.FractionNode(identifiers.perimeter.toTree(), (4).toTree()).toTex()}=${getAnswer(identifiers)}
+$$
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, perimeter }) => {
+    const node = new fractionNode_1.FractionNode(perimeter.toTree(), (4).toTree());
+    return node.toAllValidTexs({ allowFractionToDecimal: true }).includes(ans);
+};
+const getSquareSideFromPerimeterQuestion = () => {
+    const identifiers = { perimeter: (0, randfloat_1.randfloat)(1, 100, 1) };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.squareSideFromPerimeter = {
+    id: "squareSideFromPerimeter",
+    connector: "=",
+    label: "Calculer le côté d'un carré en connaissant son périmètre",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSquareSideFromPerimeterQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/trigonometry/equationCosOnRandomInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationCosOnRandomInterval.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/equationCosOnRandomInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAqBlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAyGF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAgB7D,CAAC"}
+{"version":3,"file":"equationCosOnRandomInterval.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/equationCosOnRandomInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAqBlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AA6HF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAgB7D,CAAC"}

package/lib/exercises/math/trigonometry/equationCosOnRandomInterval.js

@@ -14,11 +14,19 @@ const closure_1 = require("../../../tree/nodes/sets/closure");
 const discreteSetNode_1 = require("../../../tree/nodes/sets/discreteSetNode");
 const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
 const random_1 = require("../../../utils/alea/random");
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer, degree, leftBoundPiMultiple }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
+    //distracteur avec une solution manquante
+    if (degree !== 0 && degree !== 180) {
+        const answerNode = getAnswerNode({ degree, leftBoundPiMultiple });
+        const newSet = answerNode.solutionsSet.toDeleteRandomElement();
+        (0, exercise_1.tryToAddWrongProp)(propositions, new equationSolutionNode_1.EquationSolutionNode(newSet).toTex());
+    }
     while (propositions.length < n) {
-        throw Error("QCM not implemented");
+        const value = (0, random_1.random)(remarkableValues_1.mainPositiveTrigovalues);
+        const randDegree = value.degree;
+        (0, exercise_1.tryToAddWrongProp)(propositions, getAnswer({ degree: randDegree, leftBoundPiMultiple }));
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
@@ -66,10 +74,11 @@ const getCorrection = (identifiers) => {
     return "";
 };
 const getKeys = (identifiers) => {
-    return ["pi"];
+    return ["x", "S", "equal", "lbrace", "semicolon", "rbrace", "pi"];
 };
-const isAnswerValid = (ans, { answer }) => {
-    throw Error("VEA not implemented");
+const isAnswerValid = (ans, { answer, degree, leftBoundPiMultiple }) => {
+    const answerNode = getAnswerNode({ degree, leftBoundPiMultiple });
+    return answerNode.toAllValidTexs().includes(ans);
 };
 const getEquationCosOnRandomIntervalQuestion = () => {
     const value = (0, random_1.random)(remarkableValues_1.mainPositiveTrigovalues);

package/lib/exercises/math/trigonometry/equationSinOnRandomInterval.js

@@ -90,7 +90,7 @@ const getEquationSinOnRandomIntervalQuestion = () => {
 exports.equationSinOnRandomInterval = {
     id: "equationSinOnRandomInterval",
     connector: "\\iff",
-    label: "Résoudre une équation du type $\\Sin\\left(x\\right)=k$ sur un intervalle donné",
+    label: "Résoudre une équation du type $\\sin\\left(x\\right)=k$ sur un intervalle donné",
     isSingleStep: true,
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getEquationSinOnRandomIntervalQuestion, nb),
     qcmTimer: 60,

package/lib/exercises/math/trigonometry/index.d.ts

@@ -12,4 +12,5 @@ export * from "./basicTrigoSystemEquation";
 export * from "./mainAngleMeasure";
 export * from "./degreeToRadians";
 export * from "./arcLength";
+export * from "./equationCosOnRandomInterval";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/trigonometry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,+BAA+B,CAAC"}

package/lib/exercises/math/trigonometry/index.js

@@ -28,4 +28,4 @@ __exportStar(require("./basicTrigoSystemEquation"), exports);
 __exportStar(require("./mainAngleMeasure"), exports);
 __exportStar(require("./degreeToRadians"), exports);
 __exportStar(require("./arcLength"), exports);
-// export * from "./equationCosOnRandomInterval";
+__exportStar(require("./equationCosOnRandomInterval"), exports);

package/lib/exercises/pc/calibrationCurveOfSolution.js

@@ -58,7 +58,7 @@ const generateExercise = () => {
     const epsilon = (0, randint_1.randint)(1, 3);
     const l = (0, randint_1.randint)(1, 3);
     const instruction = `Dans un laboratoire, vous avez effectué l'étalonnage d'une solution ${(0, requiresApostropheBefore_1.requiresApostropheBefore)(molecule.name) ? "d'" : "de "}${molecule.name}. \n 
-  Vous disposez du coefficient d'extinction molaire $ε$ de $${epsilon}$ $\\text{L}\\cdot\\text{mol}^{-1}\\cdot\\text{cm}^{-1}$ et de la longueur de la cuve $l$ de $${l}$ $\\text{cm}$. \n
+  Vous disposez du coefficient d'extinction molaire $\\varepsilon$ de $${epsilon}$ $\\text{L}\\cdot\\text{mol}^{-1}\\cdot\\text{cm}^{-1}$ et de la longueur de la cuve $l$ de $${l}$ $\\text{cm}$. \n
   Tracer la courbe d'étalonnage de cette solution.`;
     return {
         instruction,
@@ -70,13 +70,13 @@ const generateExercise = () => {
 };
 const getCorrection = () => {
     return `1 - Choisir deux coordonnées $x_1$ et $x_2$. \n \\
-    2 - Calculer $A_1 = x_1\\cdot l \\cdotε$ et $A_2 = x_2\\cdot l \\cdotε$. \n \\
+    2 - Calculer $A_1 = x_1\\cdot l \\cdot \\varepsilon$ et $A_2 = x_2\\cdot l \\cdot \\varepsilon$. \n \\
     3 - Tracer la droite qui passe par les deux points $(x_1,A_1)$ et $(x_2,A_2)$.`;
 };
 const getHint = () => {
-    return `Utiliser la formule $A=C\\cdot \\ell\\cdot ε$, où :\n
+    return `Utiliser la formule $A=C\\cdot \\ell\\cdot \\varepsilon$, où :\n
 - $A$ est l'absorbance (une grandeur sans unité)\n
-- $ε$ est le coefficient d'extinction molaire (ou coefficient d'absorption molaire) en $\\text{L}\\cdot\\text{mol}^{-1}\\cdot\\text{cm}^{-1}$\n
+- $\\varepsilon$ est le coefficient d'extinction molaire (ou coefficient d'absorption molaire) en $\\text{L}\\cdot\\text{mol}^{-1}\\cdot\\text{cm}^{-1}$\n
 - $C$ est la concentration de la solution en $\\text{mol}\\cdot\\text{L}^{-1}$\n
 - $\\ell$ est la longueur du chemin optique en centimètres $(\\text{cm})$`;
 };

package/lib/index.d.ts

@@ -638,6 +638,10 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     imageValues: number[];
     isAskingImage: boolean;
     value: number;
+}> | import("./exercises/exercise").Exercise<{
+    isImage: boolean;
+    x: number;
+    y: number;
 }> | import("./exercises/exercise").Exercise<{
     k: number;
 }> | import("./exercises/exercise").Exercise<{
@@ -813,6 +817,14 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     side: number;
 }> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
     randomSide: number;
+}> | import("./exercises/exercise").Exercise<{
+    area: number;
+    isPerfectSquare: boolean;
+}> | import("./exercises/exercise").Exercise<{
+    area: number;
+    width: number;
+}> | import("./exercises/exercise").Exercise<{
+    area: number;
 }> | import("./exercises/exercise").Exercise<{
     coords1: number[];
     coords2: number[];
@@ -881,6 +893,13 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     side: number;
 }> | import("./exercises/exercise").Exercise<{
     sides: number[];
+}> | import("./exercises/exercise").Exercise<{
+    perimeter: number;
+}> | import("./exercises/exercise").Exercise<{
+    perimeter: number;
+    width: number;
+}> | import("./exercises/exercise").Exercise<{
+    perimeter: number;
 }> | import("./exercises/exercise").Exercise<{
     sideA: string;
     sideB: string;
@@ -1483,6 +1502,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     thetaInDegree: number | undefined;
     thetaInRadNodeIds: any;
     isThetaInDegree: boolean;
+}> | import("./exercises/exercise").Exercise<{
+    degree: number;
+    leftBoundPiMultiple: number;
 }> | import("./exercises/exercise").Exercise<{
     exercise: {
         a: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,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":"AAEA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

package/lib/math/numbers/reals/real.d.ts

@@ -27,6 +27,8 @@ export declare class SquareRoot extends Real {
     constructor(operand: number);
     isSimplifiable(): boolean;
     getSimplifiedCoeffs(): [number, number];
+    /**simplifier les carrés parfaits mais pas le reste */
+    basicSimplify(): Nombre;
     simplify(): Nombre;
     toTex(): string;
     toTree(): SqrtNode;

package/lib/math/numbers/reals/real.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"real.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/real.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AAS/D,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM;CAUd;AACD,qBAAa,IAAK,YAAW,MAAM;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBACL,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAKtC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM,IAAI,aAAa;CAIxB;AAED,8BAAsB,qBAAqB;IACzC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,EACxB,kBAA0B,EAC1B,SAAc,GACf;;;KAAA,GAAG,UAAU;IASd,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW,GAAG,UAAU;CAIxD;AAED,qBAAa,UAAW,SAAQ,IAAI;IAClC,OAAO,EAAE,MAAM,CAAC;gBACJ,OAAO,EAAE,MAAM;IAK3B,cAAc;IAMd,mBAAmB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IAiBvC,QAAQ,IAAI,MAAM;IAyBlB,KAAK,IAAI,MAAM;IAIf,MAAM;CAGP"}
+{"version":3,"file":"real.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/real.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AAS/D,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM;CAUd;AACD,qBAAa,IAAK,YAAW,MAAM;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBACL,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAKtC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM,IAAI,aAAa;CAIxB;AAED,8BAAsB,qBAAqB;IACzC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,EACxB,kBAA0B,EAC1B,SAAc,GACf;;;KAAA,GAAG,UAAU;IASd,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW,GAAG,UAAU;CAIxD;AAED,qBAAa,UAAW,SAAQ,IAAI;IAClC,OAAO,EAAE,MAAM,CAAC;gBACJ,OAAO,EAAE,MAAM;IAK3B,cAAc;IAMd,mBAAmB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IAkBvC,sDAAsD;IACtD,aAAa,IAAI,MAAM;IAMvB,QAAQ,IAAI,MAAM;IAyBlB,KAAK,IAAI,MAAM;IAIf,MAAM;CAGP"}

package/lib/math/numbers/reals/real.js

@@ -89,6 +89,13 @@ class SquareRoot extends Real {
         const insideSqrt = factors.length === 0 ? 1 : factors.reduce((x, y) => x * y);
         return [outsideSqrt, insideSqrt];
     }
+    /**simplifier les carrés parfaits mais pas le reste */
+    basicSimplify() {
+        if (Math.sqrt(this.operand) === this.operand) {
+            return new integer_1.Integer(this.operand);
+        }
+        return this;
+    }
     simplify() {
         if (this.operand === 0)
             return new integer_1.Integer(0);

package/lib/tree/nodes/operators/fractionNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAItB,aAAa;;;;;;;;;IAQb,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA2BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAaf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAgJ/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}
+{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAItB,aAAa;;;;;;;;;IAQb,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAaf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAgJ/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}

package/lib/tree/nodes/operators/fractionNode.js

@@ -51,7 +51,8 @@ class FractionNode {
                     const [num, denum] = [leftNode.value, rightNode.value];
                     const decimal = (0, round_1.round)(num / denum, 12);
                     //on ne push pas les non décimaux (limite arbitraire : partie décimale de 12 => non décimal)
-                    if ((decimal + "").split(".")[1].length > 11)
+                    if (Math.floor(decimal) !== decimal &&
+                        (decimal + "").split(".")[1].length > 11)
                         return;
                     res.push(new numberNode_1.NumberNode(decimal));
                 }

package/lib/types/keyIds.d.ts

@@ -14,7 +14,7 @@ export type KeyId =
 /**sets */
  | "belongs" | "notin" | "cap" | "cup" | "lbrace" | "rbrace" | "lbracket" | "rbracket" | "varnothing" | "naturals" | "integers" | "rationals" | "decimals" | "reals" | "complex" | "ast" | "del" | "right" | "left" | "rightarrow" | "overrightarrow" | "infty"
 /**fcts */
- | "log" | "ln" | "exp" | "epower" | "sin" | "cos" | "tan" | "arccos" | "arcsin" | "arctan" | "abs" | "fx"
+ | "log" | "ln" | "exp" | "epower" | "sin" | "cos" | "tan" | "arccos" | "arcsin" | "arctan" | "abs" | "fx" | "fParenthesis"
 /**sequences */
  | "un" | "unplus1"
 /**probas */

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

@@ -1 +1 @@
-{"version":3,"file":"keyIds.d.ts","sourceRoot":"","sources":["../../src/types/keyIds.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK;AACf,gBAAgB;AACd,YAAY,GACZ,aAAa,GACb,mBAAmB,GACnB,oBAAoB;AACtB,WAAW;GACT,IAAI,GACJ,KAAK,GACL,SAAS,GACT,IAAI,GACJ,KAAK,GACL,IAAI,GACJ,IAAI,GACJ,SAAS,GACT,OAAO,GACP,eAAe;AAEjB,aAAa;GACX,QAAQ,GACR,OAAO,GACP,MAAM,GACN,YAAY,GACZ,KAAK,GACL,OAAO,GACP,QAAQ,GACR,KAAK;AAEP,WAAW;GACT,IAAI,GACJ,IAAI,GACJ,OAAO;AAET,cAAc;GACZ,gBAAgB,GAChB,QAAQ,GACR,SAAS;AAEX,gBAAgB;GACd,MAAM,GACN,OAAO,GACP,OAAO,GACP,MAAM,GACN,QAAQ,GACR,MAAM,GACN,SAAS,GACT,QAAQ,GACR,MAAM,GACN,OAAO,GACP,SAAS,GACT,iBAAiB,GACjB,uBAAuB,GACvB,kBAAkB,GAClB,yBAAyB,GACzB,OAAO,GACP,OAAO,GACP,WAAW,GACX,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,QAAQ,GACR,SAAS,GACT,OAAO;AAET,UAAU;GACR,SAAS,GACT,OAAO,GACP,KAAK,GACL,KAAK,GACL,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,UAAU,GACV,YAAY,GACZ,UAAU,GACV,UAAU,GACV,WAAW,GACX,UAAU,GACV,OAAO,GACP,SAAS,GACT,KAAK,GACL,KAAK,GACL,OAAO,GACP,MAAM,GACN,YAAY,GACZ,gBAAgB,GAChB,OAAO;AAET,UAAU;GACR,KAAK,GACL,IAAI,GACJ,KAAK,GACL,QAAQ,GACR,KAAK,GACL,KAAK,GACL,KAAK,GACL,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,KAAK,GACL,IAAI;AAEN,eAAe;GACb,IAAI,GACJ,SAAS;AAEX,YAAY;GACV,eAAe,GACf,UAAU,GACV,UAAU,GACV,OAAO;AAET,aAAa;GACX,UAAU;AAEZ,WAAW;GACT,OAAO,GACP,MAAM,GACN,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,GACP,KAAK,GACL,IAAI,GACJ,KAAK,GACL,OAAO,GACP,QAAQ,GACR,IAAI,GACJ,OAAO,GACP,OAAO;AAET,cAAc;GACZ,WAAW,GACX,OAAO,GACP,QAAQ,GACR,MAAM,GACN,OAAO,GACP,YAAY,GACZ,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG;AAEL,aAAa;GACX,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG;AAEL,WAAW;GACT,WAAW,GACX,QAAQ,GACR,SAAS,GACT,WAAW,GACX,MAAM,GACN,SAAS,GACT,OAAO,GACP,SAAS,GACT,OAAO,GACP,MAAM,GACN,QAAQ,GACR,WAAW,GACX,WAAW,GACX,UAAU,GACV,WAAW,GACX,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,WAAW,GACX,SAAS,GACT,UAAU,GACV,QAAQ,GACR,UAAU,GACV,QAAQ,GACR,WAAW,GACX,KAAK,GACL,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,SAAS,GACT,WAAW,GACX,SAAS,GACT,UAAU,GACV,OAAO,GACP,SAAS,GACT,UAAU,GACV,WAAW,GACX,SAAS,GACT,WAAW,GACX,SAAS,GACT,WAAW,GACX,YAAY,GACZ,WAAW,GACX,SAAS,GACT,WAAW,GACX,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,OAAO,GACP,WAAW,GACX,SAAS,GACT,MAAM,GACN,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,QAAQ,GACR,YAAY,GACZ,SAAS,GACT,YAAY,GACZ,UAAU,GACV,UAAU,GACV,YAAY,GACZ,SAAS,GACT,YAAY,GACZ,SAAS,GACT,QAAQ,GACR,SAAS,GACT,WAAW,GACX,UAAU,GACV,SAAS,GACT,SAAS,GACT,WAAW,GACX,SAAS,GACT,QAAQ,GACR,SAAS,GACT,SAAS,GACT,IAAI,GACJ,SAAS,GACT,UAAU,GACV,OAAO,GACP,SAAS,GACT,UAAU,GACV,QAAQ,GACR,OAAO,GACP,UAAU,GACV,QAAQ,GACR,UAAU,GACV,SAAS,GACT,cAAc,GACd,SAAS,GACT,WAAW,GACX,WAAW,GACX,WAAW,GACX,QAAQ,GACR,WAAW,GACX,aAAa,GACb,aAAa,GACb,SAAS,GACT,aAAa,GACb,UAAU,GACV,YAAY,GACZ,eAAe,GACf,SAAS,GACT,YAAY,GACZ,SAAS,GACT,SAAS,GACT,YAAY,GACZ,cAAc,GACd,aAAa,GACb,aAAa,GACb,UAAU,GACV,WAAW,GACX,WAAW,GACX,aAAa,GACb,YAAY,GACZ,WAAW;AAEb,eAAe;GACb,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,YAAY,GACZ,aAAa,GACb,WAAW,GACX,UAAU,GACV,WAAW,GACX,WAAW,GACX,UAAU,GACV,UAAU,GACV,WAAW,GACX,UAAU,GACV,YAAY,GACZ,WAAW,GACX,aAAa,GACb,YAAY,GACZ,YAAY,GACZ,YAAY,GACZ,YAAY,GACZ,eAAe,GACf,aAAa,GACb,UAAU,GACV,aAAa,GACb,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,WAAW,GACX,UAAU,GACV,UAAU,GACV,WAAW,GACX,UAAU,GACV,YAAY,GACZ,UAAU,GACV,WAAW,GACX,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,aAAa,GACb,WAAW,GACX,WAAW,GACX,WAAW,GACX,YAAY,GACZ,WAAW,GACX,eAAe,GACf,SAAS,GACT,UAAU,GACV,WAAW,GACX,UAAU,GACV,WAAW,GACX,WAAW,GACX,WAAW,GACX,WAAW,GACX,WAAW,GACX,YAAY,GACZ,QAAQ,GACR,WAAW,GACX,SAAS,GACT,WAAW,GACX,UAAU,GACV,WAAW,GACX,QAAQ,GACR,UAAU,GACV,SAAS,GACT,cAAc,GACd,OAAO,GACP,YAAY,GACZ,WAAW,GACX,QAAQ,GACR,YAAY,GACZ,QAAQ,GACR,aAAa,GACb,UAAU,GACV,QAAQ,GACR,YAAY,GACZ,WAAW,GACX,SAAS,GACT,WAAW,GACX,WAAW,GACX,SAAS,GACT,SAAS,GACT,UAAU,GACV,SAAS,GACT,WAAW,GACX,WAAW,GACX,WAAW,GACX,UAAU,GACV,QAAQ,GACR,QAAQ,GACR,WAAW,GACX,UAAU,GACV,UAAU,GACV,UAAU,GACV,WAAW,GACX,UAAU,GACV,SAAS,GACT,SAAS,GACT,WAAW,GACX,YAAY,GACZ,UAAU,GACV,aAAa,GACb,WAAW,GACX,QAAQ,GACR,WAAW,GACX,WAAW,CAAC"}
+{"version":3,"file":"keyIds.d.ts","sourceRoot":"","sources":["../../src/types/keyIds.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.2.37",
+  "version": "2.2.38",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [
@@ -36,6 +36,7 @@
     "dotenv": "^16.0.3",
     "express": "^4.18.2",
     "jest": "^29.7.0",
+    "node-latex": "^3.1.0",
     "nodemon": "^2.0.22",
     "prettier": "^2.8.4",
     "ts-jest": "^29.1.1",