math-exercises 2.2.54 → 2.2.56

package/lib/exercises/math/calcul/proportionality/findCoeffInProportionalTableNonIntegers.js

@@ -67,7 +67,7 @@ const getFindCoeffInProportionalTableNonIntegersQuestion = () => {
             for (let i = 0; i < 3; i++) {
                 let x = (0, doWhile_1.doWhile)(() => (0, coinFlip_1.coinFlip)()
                     ? (0, randfloat_1.randfloat)(1.1, 10, 1).toTree()
-                    : rational_1.RationalConstructor.randomIrreductible().toTree(), (y) => y.equals(x));
+                    : rational_1.RationalConstructor.randomIrreductible().toTree(), (y) => xValues.some((x) => x.equals(y)));
                 xValues.push(x);
             }
             xValues.sort((a, b) => a.evaluate() - b.evaluate());
@@ -78,7 +78,7 @@ const getFindCoeffInProportionalTableNonIntegersQuestion = () => {
             for (let i = 0; i < 3; i++) {
                 let x = (0, doWhile_1.doWhile)(() => (0, coinFlip_1.coinFlip)()
                     ? (0, randint_1.randint)(1, 10).toTree()
-                    : (0, randfloat_1.randfloat)(1.1, 10, 1).toTree(), (y) => y.equals(x));
+                    : (0, randfloat_1.randfloat)(1.1, 10, 1).toTree(), (y) => xValues.some((x) => x.equals(y)));
                 xValues.push(x);
             }
             xValues.sort((a, b) => a.evaluate() - b.evaluate());
@@ -90,7 +90,7 @@ const getFindCoeffInProportionalTableNonIntegersQuestion = () => {
             for (let i = 0; i < 3; i++) {
                 let x = (0, doWhile_1.doWhile)(() => (0, coinFlip_1.coinFlip)()
                     ? (0, randint_1.randint)(1, 10).toTree()
-                    : rational_1.RationalConstructor.randomIrreductible().toTree(), (y) => y.equals(x));
+                    : rational_1.RationalConstructor.randomIrreductible().toTree(), (y) => xValues.some((x) => x.equals(y)));
                 xValues.push(x);
             }
             xValues.sort((a, b) => a.evaluate() - b.evaluate());

package/lib/exercises/math/calcul/proportionality/index.d.ts

@@ -4,4 +4,5 @@ export * from "./scaleCalculation";
 export * from "./scaleUsage";
 export * from "./isTableProportionalNonInteger";
 export * from "./findCoeffInProportionalTableNonIntegers";
+export * from "./isTableProportional";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/proportionality/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,iCAAiC,CAAC;AAChD,cAAc,2CAA2C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,iCAAiC,CAAC;AAChD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,uBAAuB,CAAC"}

package/lib/exercises/math/calcul/proportionality/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./scaleCalculation"), exports);
 __exportStar(require("./scaleUsage"), exports);
 __exportStar(require("./isTableProportionalNonInteger"), exports);
 __exportStar(require("./findCoeffInProportionalTableNonIntegers"), exports);
+__exportStar(require("./isTableProportional"), exports);

package/lib/exercises/math/calcul/proportionality/isTableProportional.d.ts

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

package/lib/exercises/math/calcul/proportionality/isTableProportional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTableProportional.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/isTableProportional.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AA6E5D,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAgBrD,CAAC"}

package/lib/exercises/math/calcul/proportionality/isTableProportional.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTableProportional = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randTupleInt_1 = require("../../../../math/utils/random/randTupleInt");
+const randint_1 = require("../../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../../utils/alea/coinFlip");
+const doWhile_1 = require("../../../../utils/doWhile");
+const dollarize_1 = require("../../../../utils/latex/dollarize");
+const mdTable_1 = require("../../../../utils/markdown/mdTable");
+const getInstruction = ({ xValues, yValues }) => {
+    return `Le tableau ci-dessous est-il un tableau de proportionnalité ?
+
+${(0, mdTable_1.mdTable)([xValues.map((v) => (0, dollarize_1.dollarize)(v)), yValues.map((v) => (0, dollarize_1.dollarize)(v))])}
+
+  `;
+};
+const getIsTableProportionalQuestion = () => {
+    const xValues = (0, randTupleInt_1.randTupleInt)(3, {
+        from: 1,
+        to: 15,
+        allDifferent: true,
+    }).sort((a, b) => a - b);
+    const isProportionnal = (0, coinFlip_1.coinFlip)();
+    const coeff = (0, randint_1.randint)(2, 6);
+    const fakeCoeffs = [];
+    let yValues = [];
+    if (isProportionnal) {
+        yValues = xValues.map((value) => value * coeff);
+    }
+    else {
+        xValues.forEach((x) => {
+            const newCoeff = (0, doWhile_1.doWhile)(() => (0, randint_1.randint)(2, 6), (newX) => fakeCoeffs.length === 2 &&
+                fakeCoeffs[0] === newX &&
+                fakeCoeffs[1] === newX);
+            fakeCoeffs.push(newCoeff);
+            yValues.push(x * newCoeff);
+        });
+    }
+    const identifiers = { xValues, yValues };
+    const question = {
+        answer: isProportionnal ? "Oui" : "Non",
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        style: { tableHasNoHeader: true },
+        identifiers,
+        hint: "Pour passer de la ligne du haut à la ligne du bas, multiplie-t-on toujours par le même nombre ? Si oui, alors c'est un tableau de proportionnalité.",
+        correction: `On divise les nombres de la deuxième ligne par les nombres de la première ligne. Si on obtient toujours le même résultat, alors c'est un tableau de proportionnalité. 
+
+- $${yValues[0]}\\div ${xValues[0]} = ${yValues[0] / xValues[0]}$
+
+- $${yValues[1]}\\div ${xValues[1]} = ${yValues[1] / xValues[1]}$
+
+- $${yValues[2]}\\div ${xValues[2]} = ${yValues[2] / xValues[2]}$
+
+${isProportionnal
+            ? "Puisque tous les résultats sont égaux, c'est bien un tableau de proportionnalité."
+            : "Puisque les résultats ne sont pas tous égaux, ce n'est pas un tableau de proportionnalité."}
+    `,
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "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.isTableProportional = {
+    id: "isVTableProportional",
+    label: "Reconnaître un tableau de proportionnalité",
+    levels: ["5ème"],
+    isSingleStep: true,
+    sections: ["Proportionnalité"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getIsTableProportionalQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getInstruction,
+};

package/lib/exercises/math/calcul/proportionality/isTableProportionalNonInteger.js

@@ -55,7 +55,7 @@ const getIsTableProportionalNonIntegerQuestion = () => {
             for (let i = 0; i < 3; i++) {
                 let x = (0, doWhile_1.doWhile)(() => (0, coinFlip_1.coinFlip)()
                     ? (0, randfloat_1.randfloat)(1.1, 10, 1).toTree()
-                    : rational_1.RationalConstructor.randomIrreductible().toTree(), (y) => y.equals(x));
+                    : rational_1.RationalConstructor.randomIrreductible().toTree(), (y) => xValues.some((x) => x.equals(y)));
                 xValues.push(x);
             }
             xValues.sort((a, b) => a.evaluate() - b.evaluate());
@@ -66,7 +66,7 @@ const getIsTableProportionalNonIntegerQuestion = () => {
             for (let i = 0; i < 3; i++) {
                 let x = (0, doWhile_1.doWhile)(() => (0, coinFlip_1.coinFlip)()
                     ? (0, randint_1.randint)(1, 10).toTree()
-                    : (0, randfloat_1.randfloat)(1.1, 10, 1).toTree(), (y) => y.equals(x));
+                    : (0, randfloat_1.randfloat)(1.1, 10, 1).toTree(), (y) => xValues.some((x) => x.equals(y)));
                 xValues.push(x);
             }
             xValues.sort((a, b) => a.evaluate() - b.evaluate());
@@ -78,7 +78,7 @@ const getIsTableProportionalNonIntegerQuestion = () => {
             for (let i = 0; i < 3; i++) {
                 let x = (0, doWhile_1.doWhile)(() => (0, coinFlip_1.coinFlip)()
                     ? (0, randint_1.randint)(1, 10).toTree()
-                    : rational_1.RationalConstructor.randomIrreductible().toTree(), (y) => y.equals(x));
+                    : rational_1.RationalConstructor.randomIrreductible().toTree(), (y) => xValues.some((x) => x.equals(y)));
                 xValues.push(x);
             }
             xValues.sort((a, b) => a.evaluate() - b.evaluate());

package/lib/exercises/math/calculLitteral/equation/equationType4Exercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationType4Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationType4Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAgBlC;;GAEG;AAEH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyFF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}
+{"version":3,"file":"equationType4Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationType4Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAgBlC;;GAEG;AAEH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwFF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}

package/lib/exercises/math/calculLitteral/equation/equationType4Exercise.js

@@ -65,7 +65,6 @@ const isAnswerValid = (ans, { a, b, c, d }) => {
     // try {
     //   const parsed = equationSolutionParser(ans);
     //   if (!parsed) return false;
-    //   console.log("parsed", parsed.toTex());
     //   const solution = new Rational(d - b, a - c).simplify().toTree();
     //   const solutionTex = solution.toTex();
     //   const decimal = round(solution.evaluate({}), 12).frenchify();

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;AA2DF,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":"AAOA,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;AA+DF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}

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

@@ -4,6 +4,7 @@ exports.aeraConversion = void 0;
 const decimal_1 = require("../../../math/numbers/decimals/decimal");
 const randint_1 = require("../../../math/utils/random/randint");
 const shuffle_1 = require("../../../utils/alea/shuffle");
+const doWhile_1 = require("../../../utils/doWhile");
 const exercise_1 = require("../../exercise");
 const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
 const units = ["mm", "cm", "dm", "m", "dam", "hm", "km"];
@@ -12,7 +13,7 @@ const getAeraConversion = () => {
     const randomUnitInstructionIndex = (0, randint_1.randint)(
     // cette manip a pour but d'éviter des conversion de type km² --> cm² ou le contraire (chiffre trop grand/petit)
     randomUnitIndex - 2 < 0 ? 0 : randomUnitIndex - 2, randomUnitIndex + 2 > 7 ? 7 : randomUnitIndex + 3, [randomUnitIndex]);
-    const randomAera = decimal_1.DecimalConstructor.random(0, 1000, (0, randint_1.randint)(0, 4));
+    const randomAera = (0, doWhile_1.doWhile)(() => decimal_1.DecimalConstructor.random(0, 1000, (0, randint_1.randint)(0, 4)), (x) => x.value === 0);
     const answer = (randomAera.multiplyByPowerOfTen(2 * (randomUnitIndex - randomUnitInstructionIndex)).value + "").replace(".", ",");
     const question = {
         instruction: `Compléter : $${randomAera.value

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

@@ -1 +1 @@
-{"version":3,"file":"capacityConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/capacityConversion.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAuDF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}
+{"version":3,"file":"capacityConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/capacityConversion.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA0DF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}

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

@@ -4,13 +4,14 @@ exports.capacityConversion = void 0;
 const decimal_1 = require("../../../math/numbers/decimals/decimal");
 const randint_1 = require("../../../math/utils/random/randint");
 const shuffle_1 = require("../../../utils/alea/shuffle");
+const doWhile_1 = require("../../../utils/doWhile");
 const exercise_1 = require("../../exercise");
 const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
 const units = ["mL", "cL", "dL", "L", "daL", "hL", "kL"];
 const getCapacityConversion = () => {
     const randomUnitIndex = (0, randint_1.randint)(0, 7);
     const randomUnitInstructionIndex = (0, randint_1.randint)(0, 7, [randomUnitIndex]);
-    const randomCapacity = decimal_1.DecimalConstructor.random(0, 1000, (0, randint_1.randint)(0, 4));
+    const randomCapacity = (0, doWhile_1.doWhile)(() => decimal_1.DecimalConstructor.random(0, 1000, (0, randint_1.randint)(0, 4)), (x) => x.value === 0);
     const answer = (randomCapacity.multiplyByPowerOfTen(randomUnitIndex - randomUnitInstructionIndex).value + "").replace(".", ",");
     const question = {
         instruction: `Compléter : $${randomCapacity.value

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

@@ -1 +1 @@
-{"version":3,"file":"lengthConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/lengthConversion.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,QAAQ,EAaT,MAAM,gBAAgB,CAAC;AAIxB,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AACF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAqHF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB3D,CAAC"}
+{"version":3,"file":"lengthConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/lengthConversion.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,QAAQ,EAaT,MAAM,gBAAgB,CAAC;AAIxB,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AACF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAwHF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB3D,CAAC"}

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

@@ -8,6 +8,7 @@ const measure_1 = require("../../../pc/measure/measure");
 const distanceUnits_1 = require("../../../pc/units/distanceUnits");
 const random_1 = require("../../../utils/alea/random");
 const shuffle_1 = require("../../../utils/alea/shuffle");
+const doWhile_1 = require("../../../utils/doWhile");
 const exercise_1 = require("../../exercise");
 const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
 const units = ["mm", "cm", "dm", "m", "dam", "hm", "km"];
@@ -43,7 +44,7 @@ const getLengthConversion = (options) => {
     const randomUnitInstructionIndex = (0, random_1.random)(availableUnitsIndexes, [
         randomUnitIndex,
     ]);
-    const randomLength = decimal_1.DecimalConstructor.random(0, 1000, (0, randint_1.randint)(0, 4));
+    const randomLength = (0, doWhile_1.doWhile)(() => decimal_1.DecimalConstructor.random(0, 1000, (0, randint_1.randint)(0, 4)), (x) => x.value === 0);
     const identifiers = {
         randomLength: randomLength.value,
         randomUnitIndex,

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

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

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

@@ -5,13 +5,14 @@ const decimal_1 = require("../../../math/numbers/decimals/decimal");
 const randint_1 = require("../../../math/utils/random/randint");
 const numberParser_1 = require("../../../tree/parsers/numberParser");
 const shuffle_1 = require("../../../utils/alea/shuffle");
+const doWhile_1 = require("../../../utils/doWhile");
 const exercise_1 = require("../../exercise");
 const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
 const units = ["mg", "cg", "dg", "g", "dag", "hg", "kg"];
 const getMassConversion = () => {
     const randomUnitIndex = (0, randint_1.randint)(0, 7);
     const randomUnitInstructionIndex = (0, randint_1.randint)(0, 7, [randomUnitIndex]);
-    const randomMass = decimal_1.DecimalConstructor.random(0, 1000, (0, randint_1.randint)(0, 4));
+    const randomMass = (0, doWhile_1.doWhile)(() => decimal_1.DecimalConstructor.random(0, 1000, (0, randint_1.randint)(0, 4)), (x) => x.value === 0);
     const answer = (randomMass.multiplyByPowerOfTen(randomUnitIndex - randomUnitInstructionIndex).value + "").replace(".", ",");
     const question = {
         instruction: `Compléter : $${randomMass.value

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

@@ -1 +1 @@
-{"version":3,"file":"volumeCapacityConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/volumeCapacityConversion.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AAkEF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAe1D,CAAC"}
+{"version":3,"file":"volumeCapacityConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/volumeCapacityConversion.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AAoEF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAe1D,CAAC"}

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

@@ -5,6 +5,7 @@ const decimal_1 = require("../../../math/numbers/decimals/decimal");
 const randint_1 = require("../../../math/utils/random/randint");
 const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const shuffle_1 = require("../../../utils/alea/shuffle");
+const doWhile_1 = require("../../../utils/doWhile");
 const exercise_1 = require("../../exercise");
 const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
 const volumeUnits = ["mm", "cm", "dm", "m", "dam", "hm", "km"];
@@ -14,7 +15,7 @@ const getVolumeCapacityConversion = () => {
     const randomUnitIndex = (0, randint_1.randint)(
     // cette manip a pour but d'éviter des conversion avec des nombres trop grand/petit
     randomUnitInstructionIndex - 1 < 0 ? 0 : randomUnitInstructionIndex - 1, randomUnitInstructionIndex + 2 > 7 ? 7 : randomUnitInstructionIndex + 2);
-    const random = decimal_1.DecimalConstructor.random(0, 1000, (0, randint_1.randint)(0, 4));
+    const random = (0, doWhile_1.doWhile)(() => decimal_1.DecimalConstructor.random(0, 1000, (0, randint_1.randint)(0, 4)), (x) => x.value === 0);
     let instructionUnit;
     let answerUnit;
     let answer;

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

@@ -1 +1 @@
-{"version":3,"file":"volumeConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/volumeConversion.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,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AA4DF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}
+{"version":3,"file":"volumeConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/volumeConversion.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAExB,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAiEF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}

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

@@ -4,6 +4,7 @@ exports.volumeConversion = void 0;
 const decimal_1 = require("../../../math/numbers/decimals/decimal");
 const randint_1 = require("../../../math/utils/random/randint");
 const shuffle_1 = require("../../../utils/alea/shuffle");
+const doWhile_1 = require("../../../utils/doWhile");
 const exercise_1 = require("../../exercise");
 const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
 const units = ["mm", "cm", "dm", "m", "dam", "hm", "km"];
@@ -12,7 +13,7 @@ const getVolumeConversion = () => {
     const randomUnitInstructionIndex = (0, randint_1.randint)(
     // cette manip a pour but d'éviter des conversion de type km³ --> cm³ ou le contraire (chiffre trop grand/petit)
     randomUnitIndex - 2 < 0 ? 0 : randomUnitIndex - 2, randomUnitIndex + 2 > 6 ? 6 : randomUnitIndex + 2, [randomUnitIndex]);
-    const randomVolume = decimal_1.DecimalConstructor.random(0, 1000, (0, randint_1.randint)(0, 4));
+    const randomVolume = (0, doWhile_1.doWhile)(() => decimal_1.DecimalConstructor.random(0, 1000, (0, randint_1.randint)(0, 4)), (x) => x.value === 0);
     const answer = (randomVolume.multiplyByPowerOfTen(3 * (randomUnitIndex - randomUnitInstructionIndex)).value + "").replace(".", ",");
     const question = {
         instruction: `Compléter : $${randomVolume.value

package/lib/exercises/math/geometry/shapes/basicShapesNaming.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"basicShapesNaming.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/shapes/basicShapesNaming.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AA+FxD,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAgBnD,CAAC"}
+{"version":3,"file":"basicShapesNaming.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/shapes/basicShapesNaming.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AA8FxD,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAgBnD,CAAC"}

package/lib/exercises/math/geometry/shapes/basicShapesNaming.js

@@ -42,7 +42,6 @@ const getBasicShapesNamingQuestion = () => {
         hideGrid: true,
     });
     const letters = answer.substring(1, answer.length - 1).split("");
-    // console.log(letters);
     const question = {
         answer,
         instruction: `Comment se nomme la figure suivante ?`,

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

@@ -6,7 +6,6 @@ export * from "./reciprocalPercentage";
 export * from "./percentToDecimal";
 export * from "./valuePercent";
 export * from "./findProportion";
-export * from "./isTableProportional";
 export * from "./cmToEvolution";
 export * from "./htToTTC";
 export * from "./ttcToHT";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/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;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/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;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC"}

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

@@ -22,7 +22,6 @@ __exportStar(require("./reciprocalPercentage"), exports);
 __exportStar(require("./percentToDecimal"), exports);
 __exportStar(require("./valuePercent"), exports);
 __exportStar(require("./findProportion"), exports);
-__exportStar(require("./isTableProportional"), exports);
 __exportStar(require("./cmToEvolution"), exports);
 __exportStar(require("./htToTTC"), exports);
 __exportStar(require("./ttcToHT"), exports);

package/lib/exercises/math/probaStat/probaFromTableNoContext.d.ts

@@ -8,6 +8,9 @@ type Identifiers = {
     type: string;
     probaFrac: number[];
 };
-export declare const probaFromTableNoContext: Exercise<Identifiers>;
+type Options = {
+    allowNonIrreductible?: boolean;
+};
+export declare const probaFromTableNoContext: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=probaFromTableNoContext.d.ts.map

package/lib/exercises/math/probaStat/probaFromTableNoContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probaFromTableNoContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableNoContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAyIF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAgBzD,CAAC"}
+{"version":3,"file":"probaFromTableNoContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableNoContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAgIF,KAAK,OAAO,GAAG;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAsBF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBlE,CAAC"}

package/lib/exercises/math/probaStat/probaFromTableNoContext.js

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.probaFromTableNoContext = void 0;
 const exercise_1 = require("../../../exercises/exercise");
+const allowNonIrreductibleFractions_1 = require("../../../exercises/options/allowNonIrreductibleFractions");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const rational_1 = require("../../../math/numbers/rationals/rational");
 const randint_1 = require("../../../math/utils/random/randint");
 const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const rationalParser_1 = require("../../../tree/parsers/rationalParser");
 const random_1 = require("../../../utils/alea/random");
 const dollarize_1 = require("../../../utils/latex/dollarize");
 const mdTable_1 = require("../../../utils/markdown/mdTable");
@@ -111,11 +113,20 @@ const getPropositions = (n, { answer, aBarreCapB, aBarreCapBBarre, aCapB, aCapBB
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
-const isAnswerValid = (ans, { answer, probaFrac }) => {
-    const fracTexs = new fractionNode_1.FractionNode(probaFrac[0].toTree(), probaFrac[1].toTree())
-        .simplify()
-        .toAllValidTexs();
-    return fracTexs.includes(ans);
+const options = [allowNonIrreductibleFractions_1.allowNonIrreductibleOption];
+const isAnswerValid = (ans, { answer, probaFrac }, options) => {
+    if (options?.allowNonIrreductible) {
+        const parsed = (0, rationalParser_1.rationalParser)(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    else {
+        const fracTexs = new fractionNode_1.FractionNode(probaFrac[0].toTree(), probaFrac[1].toTree())
+            .simplify()
+            .toAllValidTexs();
+        return fracTexs.includes(ans);
+    }
 };
 exports.probaFromTableNoContext = {
     id: "probaFromTableNoContext",
@@ -131,4 +142,5 @@ exports.probaFromTableNoContext = {
     isAnswerValid,
     subject: "Mathématiques",
     getInstruction,
+    options,
 };

package/lib/exercises/math/probaStat/stats1var/marginalAndConditionalFrequency.js

@@ -146,7 +146,6 @@ const getPropositions = (n, { answer, rand, x1, x2, x3, x4 }) => {
     (0, exercise_1.addValidProp)(propositions, answer);
     while (propositions.length < n) {
         const fakeRand = (0, randint_1.randint)(0, 12);
-        // console.log("marg and cond freq", answer, rand, x1, x2, x3, x4);
         const answerTree = getAnswerNode(fakeRand, x1, x2, x3, x4);
         (0, exercise_1.tryToAddWrongProp)(propositions, answerTree.toTex());
     }

package/lib/index.d.ts

@@ -137,6 +137,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     xValues: any[];
     yValues: any[];
     type: number;
+}, {}> | import("./exercises/exercise").Exercise<{
+    xValues: number[];
+    yValues: number[];
 }, {}> | import("./exercises/exercise").Exercise<{
     precisionAsked: number;
     decimal: number;
@@ -1165,9 +1168,6 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }, {}> | import("./exercises/exercise").Exercise<{
     total: number;
     lefties: number;
-}, {}> | import("./exercises/exercise").Exercise<{
-    xValues: number[];
-    yValues: number[];
 }, {}> | import("./exercises/exercise").Exercise<{
     evolution: number;
 }, {}> | import("./exercises/exercise").Exercise<{
@@ -1314,7 +1314,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     event: string;
     type: string;
     probaFrac: number[];
-}, {}> | import("./exercises/exercise").Exercise<{
+}, {
+    allowNonIrreductible?: boolean | undefined;
+}> | import("./exercises/exercise").Exercise<{
     aCapB: number;
     aCapBBarre: number;
     aBarreCapB: 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

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

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

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

@@ -101,7 +101,6 @@ class Decimal {
                     (isNegative ? "-" : "") +
                         intPartString.slice(0, power + intPartString.length);
         }
-        // console.log("in", newIntPart, newFracPart);
         return DecimalConstructor.fromParts(newIntPart, newFracPart);
     }
     toScientificPart() {
@@ -142,7 +141,6 @@ class Decimal {
         let value = decimals === undefined
             ? this.toScientificPart()
             : (0, round_1.round)(this.toScientificPart(), decimals);
-        // console.log(value);
         let power = 0;
         if (value >= 10) {
             value = 1;

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;AAED,eAAO,MAAM,IAAI,MACZ,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,iBAOnC,CAAC;AAEF,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;IAsBf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IA2J/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;CAMzD"}
+{"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;AAED,eAAO,MAAM,IAAI,MACZ,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,iBAOnC,CAAC;AAEF,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;IAsBf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAyJ/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;CAMzD"}

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

@@ -153,7 +153,6 @@ class FractionNode {
         // }
         const simplifyExternalNodes = (num, denum) => {
             if ((0, numberNode_1.isNumberNode)(num) && (0, numberNode_1.isNumberNode)(denum)) {
-                // console.log("num nb, denum nb", num.toTex(), denum.toTex());
                 if (denum.value < 0) {
                     if (num.value < 0) {
                         return new FractionNode(new numberNode_1.NumberNode(-num.value), new numberNode_1.NumberNode(-denum.value)).simplify();
@@ -176,7 +175,6 @@ class FractionNode {
             if ((0, numberNode_1.isNumberNode)(denum) &&
                 (isFractionNode(num) ||
                     ((0, oppositeNode_1.isOppositeNode)(num) && isFractionNode(num.child)))) {
-                // console.log("num frac, denum nb, ", num.toTex(), denum.toTex());
                 const trueNum = isFractionNode(num) ? num : num.child;
                 return new FractionNode(trueNum.leftChild, new multiplyNode_1.MultiplyNode(trueNum.rightChild, denum)).simplify();
             }

package/package.json

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