math-exercises 3.0.189 → 3.0.190

package/lib/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiBH.js

@@ -1,5 +1,6 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../../../exercises/utils/options/arrayedOptions.js";
 import { greenMain, orange } from "../../../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../../../geogebra/geogebraConstructor.js";
 import { Angle } from "../../../../../../math/geometry/angle.js";
@@ -387,8 +388,8 @@ const isAnswerValid = (ans, { answer }) => {
     }
 };
 const getScalarProductAlKashiBHQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? arrayedOptsDefault;
-    const sectorOfPointH = random(arrayedOptions.sectorOfPointH);
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const sectorOfPointH = random(arrayedOpts.sectorOfPointH);
     function createRandomPoints() {
         const offsetBtoC = 10;
         const pointB = new Point("B", randfloat(0, 10), randfloat(0, 10));

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductComputeBH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductComputeBH.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductComputeBH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAqBtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B,CAAC;AAmeF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CAAC;AA+BF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA6BjE,CAAC"}
+{"version":3,"file":"scalarProductComputeBH.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductComputeBH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAqBtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B,CAAC;AAkeF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CAAC;AA+BF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA6BjE,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductComputeBH.js

@@ -1,5 +1,6 @@
 import { addValidProp, shuffleProps, GeneratorOptionType, GeneratorOptionTarget, tryToAddWrongProp, propWhile, } from "../../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../../exercises/utils/options/arrayedOptions.js";
 import { orange } from "../../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
 import { Angle } from "../../../../../math/geometry/angle.js";
@@ -248,10 +249,10 @@ const isAnswerValid = (ans, { answer, ...identifiers }) => {
     }
 };
 const getScalarProductComputeBHQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? optsDefault;
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
     const opts = {
-        sectorOfPointH: random(arrayedOptions.sectorOfPointH),
-        isPositiveCoordsOnly: arrayedOptions.isPositiveCoordsOnly,
+        sectorOfPointH: random(arrayedOpts.sectorOfPointH),
+        isPositiveCoordsOnly: arrayedOpts.isPositiveCoordsOnly,
     };
     const { sectorOfPointH, isPositiveCoordsOnly } = opts;
     function createRandomIdentifiers() {
@@ -406,7 +407,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
     };
     return question;
 };
-const optsDefault = {
+const arrayedOptsDefault = {
     sectorOfPointH: ["Entre $B$ et $C$"],
     isPositiveCoordsOnly: true,
 };
@@ -417,14 +418,14 @@ const options = [
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         values: ["Entre $B$ et $C$", "Après $C$", "Avant $B$"],
-        defaultValue: optsDefault.sectorOfPointH,
+        defaultValue: arrayedOptsDefault.sectorOfPointH,
     },
     {
         id: "isPositiveCoordsOnly",
         label: "Coordonnées positives uniquement",
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.checkbox,
-        defaultValue: optsDefault.isPositiveCoordsOnly,
+        defaultValue: arrayedOptsDefault.isPositiveCoordsOnly,
     },
 ];
 export const scalarProductComputeBH = {

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

@@ -1 +1 @@
-{"version":3,"file":"percentToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/percentToDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA4JF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAsBF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe3D,CAAC"}
+{"version":3,"file":"percentToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/percentToDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA2JF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAsBF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe3D,CAAC"}

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

@@ -1,5 +1,6 @@
 import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../exercises/utils/options/arrayedOptions.js";
 import { Decimal, DecimalConstructor, } from "../../../math/numbers/decimals/decimal.js";
 import { Integer, IntegerConstructor, } from "../../../math/numbers/integer/integer.js";
 import { randint } from "../../../math/utils/random/randint.js";
@@ -82,9 +83,9 @@ const isAnswerValid = (ans, { answer, isPercentToDecimal }) => {
     }
 };
 const getPercentToDecimalQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? optsDefault;
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
     const opts = {
-        conversionType: random(arrayedOptions.conversionType),
+        conversionType: random(arrayedOpts.conversionType),
     };
     const isPercentToDecimal = opts.conversionType === "Pourcentage vers Décimal";
     const isNatural = coinFlip();
@@ -119,7 +120,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
     };
     return question;
 };
-const optsDefault = {
+const arrayedOptsDefault = {
     conversionType: ["Pourcentage vers Décimal", "Décimal vers Pourcentage"],
 };
 const options = [
@@ -129,7 +130,7 @@ const options = [
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         values: ["Pourcentage vers Décimal", "Décimal vers Pourcentage"],
-        defaultValue: optsDefault.conversionType,
+        defaultValue: arrayedOptsDefault.conversionType,
     },
 ];
 export const percentToDecimal = {

package/lib/exercises/math/probaStat/basicStats/calculateFrequencyInList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateFrequencyInList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicStats/calculateFrequencyInList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AA8LF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AAsBF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBnE,CAAC"}
+{"version":3,"file":"calculateFrequencyInList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicStats/calculateFrequencyInList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AA8LF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AAsBF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBnE,CAAC"}

package/lib/exercises/math/probaStat/basicStats/calculateFrequencyInList.js

@@ -1,5 +1,6 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
@@ -95,8 +96,8 @@ const isAnswerValid = (ans, { answer, ...identifiers }) => {
     }
 };
 const getCalculateFrequencyInListQuestion = (optsIn) => {
-    const opts = optsIn ?? optsDefault;
-    const allowedAnsType = opts.allowedAnsType;
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const allowedAnsType = arrayedOpts.allowedAnsType;
     const target = randint(1, 10);
     const length = randint(6, 13);
     const values = [];
@@ -150,7 +151,7 @@ const getAllValidNodes = (identifiers) => {
         return identifiersCopy;
     })()));
 };
-const optsDefault = {
+const arrayedOptsDefault = {
     allowedAnsType: ["exacte", "arrondie à 2 décimales"],
 };
 const options = [
@@ -160,7 +161,7 @@ const options = [
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         values: ["exacte", "arrondie à 2 décimales"],
-        defaultValue: optsDefault.allowedAnsType,
+        defaultValue: arrayedOptsDefault.allowedAnsType,
     },
 ];
 export const calculateFrequencyInList = {

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

@@ -1 +1 @@
-{"version":3,"file":"probaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE;QACN,WAAW,EAAE,MAAM,CAAC;QACpB,uBAAuB,EAAE,MAAM,CAAC;QAChC,uBAAuB,EAAE,MAAM,CAAC;QAChC,mCAAmC,EAAE,MAAM,CAAC;KAC7C,CAAC;IACF,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AA+ZF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA+BF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBpE,CAAC"}
+{"version":3,"file":"probaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE;QACN,WAAW,EAAE,MAAM,CAAC;QACpB,uBAAuB,EAAE,MAAM,CAAC;QAChC,uBAAuB,EAAE,MAAM,CAAC;QAChC,mCAAmC,EAAE,MAAM,CAAC;KAC7C,CAAC;IACF,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AA6ZF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA+BF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBpE,CAAC"}

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

@@ -1,5 +1,6 @@
 import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../exercises/utils/options/arrayedOptions.js";
 import { rationalVEA } from "../../../exercises/vea/rationalVEA.js";
 import { Rational } from "../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../math/utils/random/randint.js";
@@ -74,8 +75,8 @@ const getAnswer = (identifiers) => {
     return getAnswerNode(identifiers).toTex();
 };
 const getProbaFromTableWithContextQuestion = (optsIn) => {
-    const opts = optsIn ?? optsDefault;
-    const allowedAnsType = opts.allowedAnsType;
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const allowedAnsType = arrayedOpts.allowedAnsType;
     const aCapB = randint(1, 20);
     const aCapBBarre = randint(1, 20, [aCapB]);
     const aBarreCapB = randint(1, 20, [aCapB, aCapBBarre]);
@@ -93,9 +94,7 @@ const getProbaFromTableWithContextQuestion = (optsIn) => {
     const bBarreTotal = aBarreCapBBarre + aCapBBarre;
     let event = "";
     let proba = [];
-    const frenchType = opts?.probaTypes?.length
-        ? random(opts.probaTypes)
-        : random(["Événement simple", "Intersection", "Union"]);
+    const frenchType = random(arrayedOpts.probaTypes);
     const type = frenchType === "Événement simple"
         ? "singleEvent"
         : frenchType.toLocaleLowerCase();
@@ -284,7 +283,7 @@ const createFormattedNode = (exactNode, strInternalAllowedAnswerTypes) => {
             return exactNode;
     }
 };
-const optsDefault = {
+const arrayedOptsDefault = {
     allowedAnsType: ["exacte", "arrondie à 2 décimales"],
     probaTypes: ["Événement simple", "Intersection", "Union"],
 };
@@ -295,7 +294,7 @@ const options = [
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         values: ["exacte", "arrondie à 2 décimales"],
-        defaultValue: optsDefault.allowedAnsType,
+        defaultValue: arrayedOptsDefault.allowedAnsType,
     },
     {
         id: "probaTypes",
@@ -303,7 +302,7 @@ const options = [
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         values: ["Événement simple", "Intersection", "Union"],
-        defaultValue: optsDefault.probaTypes,
+        defaultValue: arrayedOptsDefault.probaTypes,
     },
 ];
 export const probaFromTableWithContext = {

package/lib/exercises/math/probaStat/stats1var/medianWithList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"medianWithList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/medianWithList.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAkBT,MAAM,sBAAsB,CAAC;AAE9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAmJF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAsBF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBzD,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBzE,CAAC"}
+{"version":3,"file":"medianWithList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/medianWithList.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAkBT,MAAM,sBAAsB,CAAC;AAE9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAmJF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAsBF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBzD,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBzE,CAAC"}

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

@@ -1,3 +1,4 @@
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { median } from "../../../../math/utils/stats/median.js";
@@ -81,9 +82,9 @@ const isAnswerValid = (ans, { answer, sortedValues }) => {
     }
 };
 const getMedianList = (optsIn) => {
-    const arrayedOptions = optsIn;
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
     const opts = {
-        nbValues: random(arrayedOptions.nbValues ?? optsDefault.nbValues),
+        nbValues: random(arrayedOpts.nbValues),
         isOrdered: optsIn?.isOrdered ?? false,
     };
     const length = Number(opts.nbValues);
@@ -123,7 +124,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
     };
     return question;
 };
-const optsDefault = {
+const arrayedOptsDefault = {
     nbValues: ["7", "8"],
 };
 const options = [
@@ -133,7 +134,7 @@ const options = [
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         values: ["4", "5", "7", "8", "11", "12", "19", "20"],
-        defaultValue: optsDefault.nbValues,
+        defaultValue: arrayedOptsDefault.nbValues,
     },
 ];
 export const medianWithList = {

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindRankFromSituation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFindRankFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindRankFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAKhE,OAAO,EAEL,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAM1E,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,kCAAkC,CAAC;IACrD,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA0OF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmB1E,CAAC"}
+{"version":3,"file":"arithmeticFindRankFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindRankFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAKhE,OAAO,EAEL,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAM1E,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,kCAAkC,CAAC;IACrD,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAsPF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmB1E,CAAC"}

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindRankFromSituation.js

@@ -24,7 +24,7 @@ const getAnswerNode = (identifiers, opts) => {
     const { situationIndex, initial, reason, valueAsked } = identifiers;
     const situation = situations[situationIndex];
     const rankDecoder = situation.rankDecoder;
-    return situation.variationFindRank.getAnswerStuff(initial, reason, firstRank, valueAsked, rankDecoder).answerNode;
+    return situation.variationFindRank.getAnswerStuff(initial, reason, firstRank, valueAsked, rankDecoder, situation.digitsValue, situation.digitsTarget).answerNode;
 };
 const getAnswer = (identifiers, optsIn) => {
     const opts = optsIn ?? optsDefault;
@@ -54,12 +54,12 @@ const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
     const arrNodeWrong = [];
     //student: uses valueAsked as if it were rankAsked
     {
-        const nodeWrong = situation.variationFindRandomTerm.getAnswerNode(initial, reason, firstRank, valueAsked, situation.rankDecoder);
-        tryToAddWrongProp(propositions, nodeWrong.simplify().toTex());
+        const nodeWrong = situation.variationFindRandomTerm.getAnswerNode(initial, reason, firstRank, valueAsked, situation.rankDecoder, situation.digitsValue, situation.digitsTarget);
+        tryToAddWrongProp(propositions, round(nodeWrong.simplify().evaluate(), 0).toTree().toTex());
         arrNodeWrong.push(nodeWrong);
     }
     const rankValid = (() => {
-        const { rankNode } = situation.variationFindRank.getAnswerStuff(initial, reason, firstRank, valueAsked, situation.rankDecoder);
+        const { rankNode } = situation.variationFindRank.getAnswerStuff(initial, reason, firstRank, valueAsked, situation.rankDecoder, situation.digitsValue, situation.digitsTarget);
         return round(rankNode.evaluate(), 0);
     })();
     //pseudo terror
@@ -67,7 +67,7 @@ const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
         if (coinFlip()) {
             //student: rankValid - 1
             {
-                const nodeWrong = (rankValid - 1).toTree();
+                const nodeWrong = round(rankValid - 1, 0).toTree();
                 tryToAddWrongProp(propositions, nodeWrong.toTex());
                 arrNodeWrong.push(nodeWrong);
             }
@@ -75,7 +75,7 @@ const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
         else {
             //student: rankValid + 1
             {
-                const nodeWrong = (rankValid + 1).toTree();
+                const nodeWrong = round(rankValid + 1, 0).toTree();
                 tryToAddWrongProp(propositions, nodeWrong.toTex());
                 arrNodeWrong.push(nodeWrong);
             }
@@ -83,7 +83,7 @@ const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
     }
     //random around
     {
-        const nodeWrong = Math.max(1, rankValid + randint(-5, 6, [0])).toTree();
+        const nodeWrong = round(Math.max(1, rankValid + randint(-5, 6, [0])), 0).toTree();
         tryToAddWrongProp(propositions, nodeWrong.toTex());
         arrNodeWrong.push(nodeWrong);
     }
@@ -94,7 +94,7 @@ const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
             if (coinFlip()) {
                 //student: rankValid - 1
                 {
-                    const nodeWrong = (nodePicked.evaluate() - 1).toTree();
+                    const nodeWrong = round(nodePicked.evaluate() - 1, 0).toTree();
                     tryToAddWrongProp(propositions, nodeWrong.toTex());
                     arrNodeWrong.push(nodeWrong);
                 }
@@ -102,7 +102,7 @@ const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
             else {
                 //student: rankValid + 1
                 {
-                    const nodeWrong = (nodePicked.evaluate() + 1).toTree();
+                    const nodeWrong = round(nodePicked.evaluate() + 1, 0).toTree();
                     tryToAddWrongProp(propositions, nodeWrong.toTex());
                     arrNodeWrong.push(nodeWrong);
                 }

package/lib/exercises/utils/options/arrayedOptions.d.ts

@@ -0,0 +1,2 @@
+export declare const defaultArrayedOptsWhereNeeded: <Options, ArrayedOptions>(optsIn: Options | undefined, arrayedOptions: ArrayedOptions) => ArrayedOptions & {};
+//# sourceMappingURL=arrayedOptions.d.ts.map

package/lib/exercises/utils/options/arrayedOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayedOptions.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/options/arrayedOptions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,6BAA6B,GAAI,OAAO,EAAE,cAAc,EACnE,QAAQ,OAAO,GAAG,SAAS,EAC3B,gBAAgB,cAAc,wBAmB/B,CAAC"}

package/lib/exercises/utils/options/arrayedOptions.js

@@ -0,0 +1,16 @@
+export const defaultArrayedOptsWhereNeeded = (optsIn, arrayedOptions) => {
+    const arrayedOptionsIn = optsIn;
+    return {
+        ...arrayedOptions,
+        ...(arrayedOptionsIn
+            ? Object.keys(arrayedOptionsIn).reduce((acc, key) => {
+                const dictIn = arrayedOptionsIn;
+                acc = {
+                    ...acc,
+                    ...(dictIn[key]?.length > 0 ? { [key]: dictIn[key] } : {}),
+                };
+                return acc;
+            }, {})
+            : {}),
+    };
+};

package/lib/index.d.ts

@@ -1935,6 +1935,18 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     q: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     a: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    q: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    f0: number;
+    f1: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    k: number;
+    a: number;
+    fakeParams: {
+        a: number;
+        k: number;
+    }[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     affine1Ids: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
     affine2Ids: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/math/utils/sequences/situations/seqArithmeticSituations.d.ts.map

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

package/lib/math/utils/sequences/situations/seqArithmeticSituations.js

@@ -191,8 +191,8 @@ const templatesSituationsArithmetic = [
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, _firstRank) => rank.toTree(),
-            rankFromTarget: (nodeTarget, _firstRank) => nodeTarget.evaluate(),
+            targetFromRank: (rank, _firstRank) => round(rank, 0).toTree(),
+            rankFromTarget: (nodeTarget, _firstRank) => round(nodeTarget.evaluate(), 0),
         },
         digitsValue: 2,
         digitsTarget: 0,
@@ -371,8 +371,8 @@ La hauteur de la plante relevée chaque jour, en $\\textrm{cm}$, est donc une su
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+            targetFromRank: (rank, firstRank) => round(rank - firstRank, 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() + firstRank, 0),
         },
         digitsValue: 2,
         digitsTarget: 0,
@@ -585,8 +585,8 @@ On note $u_n$ la facture (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \
             }
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+            targetFromRank: (rank, firstRank) => round(rank - firstRank, 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() + firstRank, 0),
         },
         digitsValue: 2,
         digitsTarget: 0,
@@ -738,8 +738,8 @@ La facture est donc une suite arithmétique de premier terme $${initial.frPretty
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (100 * (rank - firstRank)).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() / 100 + firstRank,
+            targetFromRank: (rank, firstRank) => round(100 * (rank - firstRank), 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() / 100 + firstRank, 0),
         },
         digitsValue: 2,
         digitsTarget: 0,
@@ -923,8 +923,8 @@ La température ambiante est donc une suite arithmétique de premier terme $${in
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+            targetFromRank: (rank, firstRank) => round(rank - firstRank, 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() + firstRank, 0),
         },
         digitsValue: 2,
         digitsTarget: 0,
@@ -1120,8 +1120,8 @@ Le salaire d'Emma, en $\\textrm{€}$, est donc une suite arithmétique de premi
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+            targetFromRank: (rank, firstRank) => round(rank - firstRank, 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() + firstRank, 0),
         },
         digitsValue: 0,
         digitsTarget: 0,
@@ -1309,8 +1309,8 @@ Le montant des économies de Manon, en $\\textrm{€}$, est donc une suite arith
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+            targetFromRank: (rank, firstRank) => round(rank - firstRank, 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() + firstRank, 0),
         },
         digitsValue: 0,
         digitsTarget: 0,
@@ -1498,8 +1498,8 @@ Le score est donc une suite arithmétique de premier terme $${initial.frPretty(0
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+            targetFromRank: (rank, firstRank) => round(rank - firstRank, 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() + firstRank, 0),
         },
         digitsValue: 2,
         digitsTarget: 0,
@@ -1690,8 +1690,8 @@ Le niveau de charge est donc une suite arithmétique de premier terme $${initial
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+            targetFromRank: (rank, firstRank) => round(rank - firstRank, 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() + firstRank, 0),
         },
         digitsValue: 0,
         digitsTarget: 0,
@@ -1881,8 +1881,8 @@ Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${i
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+            targetFromRank: (rank, firstRank) => round(rank - firstRank, 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() + firstRank, 0),
         },
         digitsValue: 0,
         digitsTarget: 0,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.189",
+  "version": "3.0.190",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [