math-exercises 3.0.131 → 3.0.133

package/lib/exercises/math/geometry/angles/isParallelUsingAngles.js

@@ -178,7 +178,7 @@ const getCorrection = (identifiers) => {
 };
 const getGGBOptions = (identifiers, opts) => {
     const { arrIntersectionIds, arrAngleIndex, arrAngleForLabel } = identifiers;
-    const nbDigits = opts?.nbDigits ?? 1;
+    const nbDigits = opts?.nbDigits ?? "1";
     const arrIntersection = arrIntersectionIds.map(IntersectionConstructor.fromIdentifiers);
     const arrAngle = arrAngleIndex.map((angleIndex, i) => arrIntersection[i].getAngle(angleIndex));
     const arrCommandPoints = arrAngle
@@ -217,7 +217,7 @@ const getGGBOptions = (identifiers, opts) => {
         //fake or real label
         `ShowLabel(${a.name}, false)`,
         ...a.getFitCaptionCommands({
-            text: round(arrAngleForLabel ? arrAngleForLabel[i] : a.evaluate(), nbDigits).frenchify(),
+            text: round(arrAngleForLabel ? arrAngleForLabel[i] : a.evaluate(), Number(nbDigits)).frenchify(),
             size: "small",
             color: ["red", "blue"][i],
         }),
@@ -241,7 +241,7 @@ const isAnswerValid = (ans, { answer }) => {
 const optsDefault = {
     angleTypes: ["alternes-internes"],
     isFakeDisplay: true,
-    nbDigits: 0,
+    nbDigits: "0",
 };
 const options = [
     {
@@ -269,7 +269,7 @@ const options = [
         label: "Nombre de décimales",
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.select,
-        values: [0, 1, 2],
+        values: ["0", "1", "2"],
         defaultValue: optsDefault.nbDigits,
     },
 ];
@@ -281,11 +281,11 @@ const getIsParallelUsingAnglesQuestion = (optsIn) => {
     function createConfigGeom(isParralelInGeom, isLookingParallel) {
         const deviation = isLookingParallel ? 1 : 5;
         const cAngleInDegreesMin = 30;
-        const cAngleInDegreesTop = randfloat(cAngleInDegreesMin, 180 - cAngleInDegreesMin, opts.nbDigits);
+        const cAngleInDegreesTop = randfloat(cAngleInDegreesMin, 180 - cAngleInDegreesMin, Number(opts.nbDigits));
         const cAngleInDegreesBottom = isParralelInGeom
             ? cAngleInDegreesTop
             : cAngleInDegreesTop +
-                randfloat(-deviation, deviation, opts.nbDigits, [0]);
+                randfloat(-deviation, deviation, Number(opts.nbDigits), [0]);
         return {
             cAngleInDegreesTop,
             cAngleInDegreesBottom,
@@ -351,10 +351,10 @@ const getIsParallelUsingAnglesQuestion = (optsIn) => {
     let arrAngleForLabel;
     if (opts.isFakeDisplay) {
         const angleInDegreesMin = 25;
-        const cAngleInDegreesTop = randfloat(angleInDegreesMin, 180 - angleInDegreesMin, opts.nbDigits);
+        const cAngleInDegreesTop = randfloat(angleInDegreesMin, 180 - angleInDegreesMin, Number(opts.nbDigits));
         const cAngleInDegreesBottom = isParralel
             ? cAngleInDegreesTop
-            : cAngleInDegreesTop + randfloat(-25, 50, opts.nbDigits, [0]);
+            : cAngleInDegreesTop + randfloat(-25, 50, Number(opts.nbDigits), [0]);
         //angles at angleIndexes 0 and 2 have same value. Same for angleIndexes 1 and 3.
         arrAngleForLabel = [cAngleInDegreesTop, cAngleInDegreesBottom].map((angle, i) => {
             return arrAngleIndex[i] % 2 == 0 ? angle : 180 - angle;

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

@@ -11,6 +11,7 @@ export * from "./readAbscissOnLine.js";
 export * from "./readAbscissOnSemiLine.js";
 export * from "./placeAbscissOnLine.js";
 export * from "./placeAbscissOnSemiLine.js";
+export * from "./placeAbscissOnSemiLineV2.js";
 export * from "./cartesianFromVectorAndPoint.js";
 export * from "./cartesianFromTwoPoints.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC"}

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

@@ -12,5 +12,6 @@ export * from "./readAbscissOnLine.js";
 export * from "./readAbscissOnSemiLine.js";
 export * from "./placeAbscissOnLine.js";
 export * from "./placeAbscissOnSemiLine.js";
+export * from "./placeAbscissOnSemiLineV2.js";
 export * from "./cartesianFromVectorAndPoint.js";
 export * from "./cartesianFromTwoPoints.js";

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLine.d.ts

@@ -1,16 +1,13 @@
 import { Exercise } from "../../../../exercises/exercise.js";
 import { NumberType } from "../../../../math/numbers/nombre.js";
-import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
 type Identifiers = {
     abscissType: NumberType;
-    axisUnit: NodeIdentifiers;
-    absciss1: NodeIdentifiers;
-    absciss2: NodeIdentifiers;
+    axisUnit: number;
+    oneUnitTex: string;
+    absciss: number;
+    abscissTex: string;
+    coeff: number;
 };
-type Options = {
-    questionType: "standard" | "éviter le comptage";
-    numberType: "Entiers" | "Rationnels" | "Décimaux";
-};
-export declare const placeAbscissOnSemiLine: Exercise<Identifiers, Options>;
+export declare const placeAbscissOnSemiLine: Exercise<Identifiers>;
 export {};
 //# sourceMappingURL=placeAbscissOnSemiLine.d.ts.map

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"placeAbscissOnSemiLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnSemiLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAK1D,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAkOF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,UAAU,GAAG,oBAAoB,CAAC;IAChD,UAAU,EAAE,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;CACnD,CAAC;AA6BF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAYjE,CAAC"}
+{"version":3,"file":"placeAbscissOnSemiLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnSemiLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAQ1D,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA6IF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAWxD,CAAC"}

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

@@ -1,56 +1,32 @@
-import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-import { GeogebraParser } from "../../../../geogebra/parsers/geogebraParser.js";
 import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
 import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
 import { Point } from "../../../../math/geometry/point.js";
 import { NumberType } from "../../../../math/numbers/nombre.js";
-import { dividersOf } from "../../../../math/utils/arithmetic/dividersOf.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
-import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
-import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
-import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { random } from "../../../../utils/alea/random.js";
-const getInstruction = ({ abscissType, absciss2, }) => {
-    const absciss2Node = NodeConstructor.fromIdentifiers(absciss2);
-    return `Placer le point d'abscisse $${abscissType === NumberType.Decimal
-        ? round(absciss2Node.evaluate(), 1).frenchify()
-        : absciss2Node.toTex()}$ sur la demi-droite graduée ci-dessous :`;
+const getInstruction = ({ abscissTex }) => {
+    return `Placer le point d'abscisse $${abscissTex}$ sur la demi-droite graduée ci-dessous :`;
 };
 // const getHint: GetHint<Identifiers> = (identifiers) => {};
 // const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
-const getGGBAnswer = ({ absciss2 }) => {
-    const nodeAbciss2 = NodeConstructor.fromIdentifiers(absciss2);
-    return [`(${nodeAbciss2.evaluate()},0)`];
+const getGGBAnswer = ({ coeff }) => {
+    return [`(${coeff},0)`];
 };
-const getStudentGGBOptions = ({ abscissType, absciss1, axisUnit, absciss2, }) => {
-    const [axisUnitNode, absciss1Node, absciss2Node] = [
-        axisUnit,
-        absciss1,
-        absciss2,
-    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
-    const [valueAxisUnit, valueAbsciss1, valueAbsciss2] = [
-        axisUnitNode,
-        absciss1Node,
-        absciss2Node,
-    ].map((node) => node.evaluate());
-    const xMin = Math.min(Math.min(0, valueAbsciss1), valueAbsciss2);
-    const xMax = Math.max(Math.max(0, valueAbsciss1), valueAbsciss2);
-    const yxRatio = 0.5;
-    const yMax = yxRatio * (xMax - xMin);
-    const yMin = -yMax;
+const getStudentGGBOptions = ({ oneUnitTex, abscissType, }) => {
     const O = new Point("O", (0).toTree(), (0).toTree());
-    const I = new Point("I", absciss1Node, (0).toTree());
+    const I = new Point("I", (1).toTree(), (0).toTree());
     const commands = [
         ...O.toGGBCommand(),
-        `Text("\\footnotesize 0", (0, ${yMin / 4}), false, true, 0, 0)`,
+        `Text("\\footnotesize 0", (0, -0.5), false, true, 0, 0)`,
         ...I.toGGBCommand(),
-        `Text("\\footnotesize ${abscissType === NumberType.Decimal
-            ? round(absciss1Node.evaluate(), 1).frenchify()
-            : absciss1Node.toTex()}", (${valueAbsciss1}, ${abscissType === NumberType.Rational ? yMin / 2 : yMin / 4}), false, true, 0, 0)`,
+        `Text("\\footnotesize ${oneUnitTex}", (1, ${abscissType === NumberType.Rational ? -1 : -0.5}), false, true, 0, 0)`,
     ];
     const ggb = new GeogebraConstructor({
         commands,
@@ -60,7 +36,7 @@ const getStudentGGBOptions = ({ abscissType, absciss1, axisUnit, absciss2, }) =>
         hideGrid: true,
         xAxis: {
             hideNumbers: true,
-            steps: valueAxisUnit,
+            steps: 1,
             showPositive: true,
         },
         yAxis: {
@@ -70,102 +46,73 @@ const getStudentGGBOptions = ({ abscissType, absciss1, axisUnit, absciss2, }) =>
         forbidShiftDragZoom: true,
     });
     return ggb.getOptions({
-        coords: ggb.getAdaptedCoords({
-            xMin,
-            xMax,
-            yMin,
-            yMax,
-        }),
-        // coords: [xMin, xMax, yMin, yMax],
+        coords: [-1, 10, -2, 2],
     });
 };
-const isGGBAnswerValid = (ans, { absciss2, axisUnit }) => {
-    const [absciss2Node, axisUnitNode] = [absciss2, axisUnit].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
-    const commands = ans;
-    const dictObj = new GeogebraParser(commands).objectDict();
-    console.log("dictObj:", dictObj);
-    const strPointA = dictObj["A"];
-    if (!strPointA) {
-        return false;
-    }
-    const coordsA = ggbPointToCoords(strPointA);
+const isGGBAnswerValid = (ans, { coeff }) => {
     const points = parseGGBPoints(ans).map((p) => ggbPointToCoords(p));
-    return (points.length === 3 && //O,I,A
-        Math.abs(coordsA.y) < 0.5 * axisUnitNode.evaluate() &&
-        Math.abs(coordsA.x - absciss2Node.evaluate()) <
-            0.1 * axisUnitNode.evaluate());
+    return (points.length === 1 &&
+        Math.abs(points[0].y) < 0.5 &&
+        Math.abs(points[0].x - coeff) < 0.1);
 };
-const getPlaceAbscissOnSemiLineQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? optsDefault;
-    const opts = {
-        questionType: random(arrayedOptions.questionType),
-        numberType: random(arrayedOptions.numberType),
-    };
-    const abscissType = (() => {
-        switch (opts.numberType) {
-            case "Entiers":
-                return NumberType.Integer;
-            case "Rationnels":
-                return NumberType.Rational;
-            case "Décimaux":
-                return NumberType.Decimal;
-        }
-    })();
-    //[ [1/2, 2/2, 3/2], [1/3,2/3,3/3,4/3,5/3], ...]
-    function fracFamilyList() {
-        const maxDen = 5;
-        return [...Array(maxDen - 2).keys()]
-            .map((index) => index + 2)
-            .map((den) => [...Array(den === 2 ? 3 * den - 1 : 2 * den - 1).keys()]
-            .map((index) => index + 1)
-            .filter((num) => opts.questionType === "éviter le comptage"
-            ? num !== 1 && num !== den
-            : true)
-            .map((num) => frac(num, den)));
-    }
-    const fracList = random(fracFamilyList());
-    const den = fracList[0].rightChild;
-    const factor1 = random(fracList);
-    const factor2 = random(fracList, [factor1]);
-    let referenceNum;
-    let absciss1Node;
-    let absciss2Node;
+const getPlaceAbscissOnSemiLineQuestion = () => {
+    const abscissType = random([
+        NumberType.Integer,
+        NumberType.Rational,
+        NumberType.Decimal,
+    ]);
+    let absciss, axisUnit, oneUnitTex, abscissTex, coeff;
     switch (abscissType) {
         case NumberType.Integer:
-            {
-                referenceNum = multiply(randint(1, 13), den);
-                absciss1Node = multiply(referenceNum, factor1).simplify();
-                absciss2Node = multiply(referenceNum, factor2).simplify();
-            }
+            axisUnit = randint(1, 10);
+            coeff = randint(2, 10);
+            absciss = axisUnit * coeff;
+            oneUnitTex = axisUnit.frenchify();
+            abscissTex = absciss.frenchify();
             break;
         case NumberType.Rational:
             {
-                referenceNum = random([...Array(19).keys()]
-                    .map((index) => index + 1)
-                    .filter((num) => !dividersOf(num).includes(den.evaluate()))).toTree();
-                absciss1Node = frac(multiply(referenceNum, factor1.leftChild).simplify(), factor1.rightChild);
-                absciss2Node = frac(multiply(referenceNum, factor2.leftChild).simplify(), factor2.rightChild);
+                const randomFrac = random([
+                    [1, 2],
+                    [1, 3],
+                    [2, 3],
+                    [1, 4],
+                    [3, 4],
+                    [1, 5],
+                    [2, 5],
+                    [3, 5],
+                    [4, 5],
+                ]);
+                axisUnit = randomFrac[0] / randomFrac[1];
+                const oneUnit = new FractionNode(randomFrac[0].toTree(), randomFrac[1].toTree());
+                oneUnitTex = oneUnit.toTex();
+                coeff = randint(2, 10);
+                absciss = axisUnit * coeff;
+                abscissTex = new MultiplyNode(oneUnit, coeff.toTree())
+                    .simplify()
+                    .toTex();
             }
             break;
         case NumberType.Decimal:
         default:
-            {
-                referenceNum = frac(multiply(randint(1, 13 * 10), den), 10);
-                absciss1Node = multiply(referenceNum, factor1).simplify();
-                absciss2Node = multiply(referenceNum, factor2).simplify();
-            }
+            axisUnit = randfloat(0, 5, 1);
+            coeff = randint(2, 10);
+            absciss = round(axisUnit * coeff, 2);
+            oneUnitTex = axisUnit.frenchify();
+            abscissTex = absciss.frenchify();
             break;
     }
-    const axisUnitNode = frac(referenceNum, den).simplify();
     const identifiers = {
+        absciss,
+        abscissTex,
         abscissType,
-        axisUnit: axisUnitNode.toIdentifiers(),
-        absciss1: absciss1Node.toIdentifiers(),
-        absciss2: absciss2Node.toIdentifiers(),
+        axisUnit,
+        coeff,
+        oneUnitTex,
     };
     return getQuestionFromIdentifiers(identifiers);
 };
-const getQuestionFromIdentifiers = (identifiers, opts) => {
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         ggbAnswer: getGGBAnswer(identifiers),
         instruction: getInstruction(identifiers),
@@ -173,38 +120,14 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         identifiers,
         // hint: getHint(identifiers),
         // correction: getCorrection(identifiers),
-        options: opts,
     };
     return question;
 };
-const optsDefault = {
-    questionType: ["standard", "éviter le comptage"],
-    numberType: ["Entiers", "Rationnels", "Décimaux"],
-};
-const options = [
-    {
-        id: "questionType",
-        label: "Type de question",
-        target: GeneratorOptionTarget.generation,
-        type: GeneratorOptionType.multiselect,
-        values: ["standard", "éviter le comptage"],
-        defaultValue: optsDefault.questionType,
-    },
-    {
-        id: "numberType",
-        label: "Type de nombres",
-        target: GeneratorOptionTarget.generation,
-        type: GeneratorOptionType.multiselect,
-        values: ["Entiers", "Rationnels", "Décimaux"],
-        defaultValue: optsDefault.numberType,
-    },
-];
 export const placeAbscissOnSemiLine = {
     id: "placeAbscissOnSemiLine",
     label: "Placer un point d'abscisse donnée sur une demi-droite graduée",
     isSingleStep: true,
-    generator: (nb, opts) => getDistinctQuestions(() => getPlaceAbscissOnSemiLineQuestion(opts), nb),
-    options,
+    generator: (nb) => getDistinctQuestions(getPlaceAbscissOnSemiLineQuestion, nb),
     ggbTimer: 60,
     isGGBAnswerValid,
     subject: "Mathématiques",

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.d.ts

@@ -0,0 +1,16 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NumberType } from "../../../../math/numbers/nombre.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    abscissType: NumberType;
+    axisUnit: NodeIdentifiers;
+    absciss1: NodeIdentifiers;
+    absciss2: NodeIdentifiers;
+};
+type Options = {
+    questionType: "standard" | "éviter le comptage";
+    numberType: "Entiers" | "Rationnels" | "Décimaux";
+};
+export declare const placeAbscissOnSemiLineV2: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=placeAbscissOnSemiLineV2.d.ts.map

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placeAbscissOnSemiLineV2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAK1D,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAkOF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,UAAU,GAAG,oBAAoB,CAAC;IAChD,UAAU,EAAE,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;CACnD,CAAC;AA6BF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAYnE,CAAC"}

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

@@ -0,0 +1,213 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { GeogebraParser } from "../../../../geogebra/parsers/geogebraParser.js";
+import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { NumberType } from "../../../../math/numbers/nombre.js";
+import { dividersOf } from "../../../../math/utils/arithmetic/dividersOf.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { random } from "../../../../utils/alea/random.js";
+const getInstruction = ({ abscissType, absciss2, }) => {
+    const absciss2Node = NodeConstructor.fromIdentifiers(absciss2);
+    return `Placer le point d'abscisse $${abscissType === NumberType.Decimal
+        ? round(absciss2Node.evaluate(), 1).frenchify()
+        : absciss2Node.toTex()}$ sur la demi-droite graduée ci-dessous :`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = ({ absciss2 }) => {
+    const nodeAbciss2 = NodeConstructor.fromIdentifiers(absciss2);
+    return [`(${nodeAbciss2.evaluate()},0)`];
+};
+const getStudentGGBOptions = ({ abscissType, absciss1, axisUnit, absciss2, }) => {
+    const [axisUnitNode, absciss1Node, absciss2Node] = [
+        axisUnit,
+        absciss1,
+        absciss2,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [valueAxisUnit, valueAbsciss1, valueAbsciss2] = [
+        axisUnitNode,
+        absciss1Node,
+        absciss2Node,
+    ].map((node) => node.evaluate());
+    const xMin = Math.min(Math.min(0, valueAbsciss1), valueAbsciss2);
+    const xMax = Math.max(Math.max(0, valueAbsciss1), valueAbsciss2);
+    const yxRatio = 0.5;
+    const yMax = yxRatio * (xMax - xMin);
+    const yMin = -yMax;
+    const O = new Point("O", (0).toTree(), (0).toTree());
+    const I = new Point("I", absciss1Node, (0).toTree());
+    const commands = [
+        ...O.toGGBCommand(),
+        `Text("\\footnotesize 0", (0, ${yMin / 4}), false, true, 0, 0)`,
+        ...I.toGGBCommand(),
+        `Text("\\footnotesize ${abscissType === NumberType.Decimal
+            ? round(absciss1Node.evaluate(), 1).frenchify()
+            : absciss1Node.toTex()}", (${valueAbsciss1}, ${abscissType === NumberType.Rational ? yMin / 2 : yMin / 4}), false, true, 0, 0)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+        hideGrid: true,
+        xAxis: {
+            hideNumbers: true,
+            steps: valueAxisUnit,
+            showPositive: true,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        maxHeight: 220,
+        forbidShiftDragZoom: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+        }),
+        // coords: [xMin, xMax, yMin, yMax],
+    });
+};
+const isGGBAnswerValid = (ans, { absciss2, axisUnit }) => {
+    const [absciss2Node, axisUnitNode] = [absciss2, axisUnit].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const commands = ans;
+    const dictObj = new GeogebraParser(commands).objectDict();
+    console.log("dictObj:", dictObj);
+    const strPointA = dictObj["A"];
+    if (!strPointA) {
+        return false;
+    }
+    const coordsA = ggbPointToCoords(strPointA);
+    const points = parseGGBPoints(ans).map((p) => ggbPointToCoords(p));
+    return (points.length === 3 && //O,I,A
+        Math.abs(coordsA.y) < 0.5 * axisUnitNode.evaluate() &&
+        Math.abs(coordsA.x - absciss2Node.evaluate()) <
+            0.1 * axisUnitNode.evaluate());
+};
+const getPlaceAbscissOnSemiLineV2Question = (optsIn) => {
+    const arrayedOptions = optsIn ?? optsDefault;
+    const opts = {
+        questionType: random(arrayedOptions.questionType),
+        numberType: random(arrayedOptions.numberType),
+    };
+    const abscissType = (() => {
+        switch (opts.numberType) {
+            case "Entiers":
+                return NumberType.Integer;
+            case "Rationnels":
+                return NumberType.Rational;
+            case "Décimaux":
+                return NumberType.Decimal;
+        }
+    })();
+    //[ [1/2, 2/2, 3/2], [1/3,2/3,3/3,4/3,5/3], ...]
+    function fracFamilyList() {
+        const maxDen = 5;
+        return [...Array(maxDen - 2).keys()]
+            .map((index) => index + 2)
+            .map((den) => [...Array(den === 2 ? 3 * den - 1 : 2 * den - 1).keys()]
+            .map((index) => index + 1)
+            .filter((num) => opts.questionType === "éviter le comptage"
+            ? num !== 1 && num !== den
+            : true)
+            .map((num) => frac(num, den)));
+    }
+    const fracList = random(fracFamilyList());
+    const den = fracList[0].rightChild;
+    const factor1 = random(fracList);
+    const factor2 = random(fracList, [factor1]);
+    let referenceNum;
+    let absciss1Node;
+    let absciss2Node;
+    switch (abscissType) {
+        case NumberType.Integer:
+            {
+                referenceNum = multiply(randint(1, 13), den);
+                absciss1Node = multiply(referenceNum, factor1).simplify();
+                absciss2Node = multiply(referenceNum, factor2).simplify();
+            }
+            break;
+        case NumberType.Rational:
+            {
+                referenceNum = random([...Array(19).keys()]
+                    .map((index) => index + 1)
+                    .filter((num) => !dividersOf(num).includes(den.evaluate()))).toTree();
+                absciss1Node = frac(multiply(referenceNum, factor1.leftChild).simplify(), factor1.rightChild);
+                absciss2Node = frac(multiply(referenceNum, factor2.leftChild).simplify(), factor2.rightChild);
+            }
+            break;
+        case NumberType.Decimal:
+        default:
+            {
+                referenceNum = frac(multiply(randint(1, 13 * 10), den), 10);
+                absciss1Node = multiply(referenceNum, factor1).simplify();
+                absciss2Node = multiply(referenceNum, factor2).simplify();
+            }
+            break;
+    }
+    const axisUnitNode = frac(referenceNum, den).simplify();
+    const identifiers = {
+        abscissType,
+        axisUnit: axisUnitNode.toIdentifiers(),
+        absciss1: absciss1Node.toIdentifiers(),
+        absciss2: absciss2Node.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    questionType: ["standard", "éviter le comptage"],
+    numberType: ["Entiers", "Rationnels", "Décimaux"],
+};
+const options = [
+    {
+        id: "questionType",
+        label: "Type de question",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["standard", "éviter le comptage"],
+        defaultValue: optsDefault.questionType,
+    },
+    {
+        id: "numberType",
+        label: "Type de nombres",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Entiers", "Rationnels", "Décimaux"],
+        defaultValue: optsDefault.numberType,
+    },
+];
+export const placeAbscissOnSemiLineV2 = {
+    id: "placeAbscissOnSemiLineV2",
+    label: "Placer un point d'abscisse donnée sur une demi-droite graduée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlaceAbscissOnSemiLineV2Question(opts), nb),
+    options,
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "GGB",
+};

package/lib/exercises/math/percent/evolutions/globalPercent.d.ts

@@ -2,6 +2,9 @@ import { Exercise } from "../../../exercise.js";
 type Identifiers = {
     evolutions: string[];
 };
-export declare const globalPercent: Exercise<Identifiers>;
+type Options = {
+    nbEvos: string;
+};
+export declare const globalPercent: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=globalPercent.d.ts.map

package/lib/exercises/math/percent/evolutions/globalPercent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"globalPercent.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/percent/evolutions/globalPercent.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAM9B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA4GF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAe/C,CAAC"}
+{"version":3,"file":"globalPercent.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/percent/evolutions/globalPercent.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAiBT,MAAM,sBAAsB,CAAC;AAM9B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAmHF,KAAK,OAAO,GAAG;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAgBF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBxD,CAAC"}