math-exercises 3.0.124 → 3.0.126

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

@@ -1,32 +1,56 @@
+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 { randfloat } from "../../../../math/utils/random/randfloat.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 { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
-import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.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 = ({ abscissTex }) => {
-    return `Placer le point d'abscisse $${abscissTex}$ sur la demi-droite graduée ci-dessous :`;
+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 = ({ coeff }) => {
-    return [`(${coeff},0)`];
+const getGGBAnswer = ({ absciss2 }) => {
+    const nodeAbciss2 = NodeConstructor.fromIdentifiers(absciss2);
+    return [`(${nodeAbciss2.evaluate()},0)`];
 };
-const getStudentGGBOptions = ({ oneUnitTex, abscissType, }) => {
+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", (1).toTree(), (0).toTree());
+    const I = new Point("I", absciss1Node, (0).toTree());
     const commands = [
         ...O.toGGBCommand(),
-        `Text("\\footnotesize 0", (0, -0.5), false, true, 0, 0)`,
+        `Text("\\footnotesize 0", (0, ${yMin / 4}), false, true, 0, 0)`,
         ...I.toGGBCommand(),
-        `Text("\\footnotesize ${oneUnitTex}", (1, ${abscissType === NumberType.Rational ? -1 : -0.5}), false, true, 0, 0)`,
+        `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,
@@ -36,7 +60,7 @@ const getStudentGGBOptions = ({ oneUnitTex, abscissType, }) => {
         hideGrid: true,
         xAxis: {
             hideNumbers: true,
-            steps: 1,
+            steps: valueAxisUnit,
             showPositive: true,
         },
         yAxis: {
@@ -46,70 +70,102 @@ const getStudentGGBOptions = ({ oneUnitTex, abscissType, }) => {
         forbidShiftDragZoom: true,
     });
     return ggb.getOptions({
-        coords: [-1, 10, -2, 2],
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+        }),
+        // coords: [xMin, xMax, yMin, yMax],
     });
 };
-const isGGBAnswerValid = (ans, { coeff }) => {
+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 === 1 &&
-        Math.abs(points[0].y) < 0.5 &&
-        Math.abs(points[0].x - coeff) < 0.1);
+    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 getPlaceAbscissOnSemiLineQuestion = () => {
-    const abscissType = random([
-        NumberType.Integer,
-        NumberType.Rational,
-        NumberType.Decimal,
-    ]);
-    let absciss, axisUnit, oneUnitTex, abscissTex, coeff;
+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;
     switch (abscissType) {
         case NumberType.Integer:
-            axisUnit = randint(1, 10);
-            coeff = randint(2, 10);
-            absciss = axisUnit * coeff;
-            oneUnitTex = axisUnit.frenchify();
-            abscissTex = absciss.frenchify();
+            {
+                referenceNum = multiply(randint(1, 13), den);
+                absciss1Node = multiply(referenceNum, factor1).simplify();
+                absciss2Node = multiply(referenceNum, factor2).simplify();
+            }
             break;
-        case NumberType.Rational: {
-            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();
+        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:
-            axisUnit = randfloat(0, 5, 1);
-            coeff = randint(2, 10);
-            absciss = round(axisUnit * coeff, 2);
-            oneUnitTex = axisUnit.frenchify();
-            abscissTex = absciss.frenchify();
+            {
+                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 = {
-        absciss,
-        abscissTex,
         abscissType,
-        axisUnit,
-        coeff,
-        oneUnitTex,
+        axisUnit: axisUnitNode.toIdentifiers(),
+        absciss1: absciss1Node.toIdentifiers(),
+        absciss2: absciss2Node.toIdentifiers(),
     };
     return getQuestionFromIdentifiers(identifiers);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
         ggbAnswer: getGGBAnswer(identifiers),
         instruction: getInstruction(identifiers),
@@ -117,14 +173,38 @@ const getQuestionFromIdentifiers = (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 placeAbscissOnSemiLine = {
     id: "placeAbscissOnSemiLine",
     label: "Placer un point d'abscisse donnée sur une demi-droite graduée",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getPlaceAbscissOnSemiLineQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getPlaceAbscissOnSemiLineQuestion(opts), nb),
+    options,
     ggbTimer: 60,
     isGGBAnswerValid,
     subject: "Mathématiques",

package/lib/exercises/math/geometry/convexity/convexityQuadrinomialsGeo.js

@@ -43,7 +43,7 @@ function generateEvenInflexionPoint() {
 const getInstruction = (identifiers) => {
     const { askConvex } = identifiers;
     const questionType = askConvex ? "convexe" : "concave";
-    const instruction = `Ci-dessous est tracée la courbe représentative $\\mathcal C_f$ d'une fonction $f$. Sur quel intervalle $f$ est-elle ${questionType} ?`;
+    const instruction = `Ci-dessous est tracée la courbe représentative $\\mathcal C_f$ d'une fonction $f$. Sur quel intervalle $f$ est-elle strictement ${questionType} ?`;
     return instruction;
 };
 const getAnswer = (identifiers) => {

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

@@ -1 +1 @@
-{"version":3,"file":"circleCircumference.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/circleCircumference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAoGF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}
+{"version":3,"file":"circleCircumference.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/circleCircumference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA2GF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

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

@@ -2,6 +2,8 @@ import { addValidProp, tryToAddWrongProp, propWhile, } from "../../../../exercis
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers) => {
@@ -10,14 +12,15 @@ const getInstruction = (identifiers) => {
         ? "rayon " + `$${radius}\\ \\textrm{cm}$`
         : "diamètre " + `$${diametre} \\ \\textrm{cm}$`} (arrondir au centième de $\\textrm{cm}$).`;
 };
-const getAnswer = (identifiers) => {
+const getAnswerNode = (identifiers) => {
     const { coin, radius, diametre } = identifiers;
     const answerNb = coin
         ? round(2 * Math.PI * radius, 2)
         : round(Math.PI * diametre, 2);
-    const answer = answerNb.frenchify();
-    const answerTex = answer + "\\text{cm}";
-    return answerTex;
+    return answerNb.toTree();
+};
+const getAnswer = (identifiers) => {
+    return `${getAnswerNode(identifiers).toTex()} \\text{cm}`;
 };
 const getHint = () => {
     return `Le périmètre d'un cercle de rayon $r$ est donné par : 
@@ -79,9 +82,14 @@ const getPropositions = (n, { answer }) => {
     });
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { answer }) => {
-    const texs = [answer, answer.split("\\text")[0]];
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    if (ans.includes("\\text{cm}^2")) {
+        return false;
+    }
+    const refinedAns = ans.replace("\\text{cm}", "");
+    const ansNode = parseAlgebraic(refinedAns);
+    const answerNode = getAnswerNode(identifiers);
+    return substract(ansNode, answerNode).evaluate() === 0;
 };
 export const circleCircumference = {
     id: "circleCircumference",

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,EAgBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,eAAe,EAChB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAGL,cAAc,EACf,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAEL,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AAKxC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,kBAAkB,GAAG,cAAc,GAAG,eAAe,CAAC;CAC/D,CAAC;AAiKF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAenD,CAAC"}
+{"version":3,"file":"basicShapesNaming.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/shapes/basicShapesNaming.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,eAAe,EAChB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAGL,cAAc,EACf,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAEL,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AAKxC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,kBAAkB,GAAG,cAAc,GAAG,eAAe,CAAC;CAC/D,CAAC;AAmKF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAenD,CAAC"}

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

@@ -31,7 +31,7 @@ const getAnswer = (identifiers) => {
             break;
         case 3: //droite
         default:
-            return obj.toTexNoLeftRight();
+            return `(${obj.toTexNoLeftRight()})`;
             break;
     }
 };
@@ -105,12 +105,14 @@ const getBasicShapesNamingQuestion = () => {
     const type = randint(1, 4);
     let objIds;
     switch (type) {
-        case 1: { //segment
+        case 1: {
+            //segment
             const segment = SegmentConstructor.random();
             objIds = segment.toIdentifiers();
             break;
         }
-        case 2: { //demi-droite
+        case 2: {
+            //demi-droite
             const ray = RayConstructor.random();
             objIds = ray.toIdentifiers();
             break;

package/lib/exercises/math/geometry/vectors/colinearity/colinearityFromPicture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"colinearityFromPicture.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/colinearity/colinearityFromPicture.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAOtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,SAAS,EAAE,gBAAgB,EAAE,CAAC;CAC/B,CAAC;AA+NF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}
+{"version":3,"file":"colinearityFromPicture.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/colinearity/colinearityFromPicture.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAOtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,SAAS,EAAE,gBAAgB,EAAE,CAAC;CAC/B,CAAC;AA+OF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}

package/lib/exercises/math/geometry/vectors/colinearity/colinearityFromPicture.js

@@ -60,126 +60,143 @@ const isAnswerValid = () => {
     }
 };
 const getColinearityFromPictureQuestion = () => {
-    const points = [];
-    let letterIndex = 65; //"A"
-    for (let j = 0; j < 4; j++) {
-        for (let i = 0; i < 3; i++) {
-            points.push(new Point(String.fromCharCode(letterIndex), i, j));
-            letterIndex++;
+    let firstVec, secondVec;
+    let isGenerationOk = false;
+    const generate = () => {
+        const points = [];
+        let letterIndex = 65; //"A"
+        for (let j = 0; j < 4; j++) {
+            for (let i = 0; i < 3; i++) {
+                points.push(new Point(String.fromCharCode(letterIndex), i, j));
+                letterIndex++;
+            }
         }
-    }
-    //!mama mia
-    //pardon au moi du futur
-    //en gros l'idée est qu'on construit deux paires de coordonnées de vecteurs colinéaires (ou non colinéaires) puis on boucle à l'infini sur les points pour trouver des points correspondants aux coordonnées des vecteurs choisis
-    let firstVecCoords, secondVecCoords;
-    const isColinear = coinFlip();
-    if (isColinear) {
-        const choices = [
-            [
-                [1, 0],
-                [2, 0],
-            ],
-            [
-                [0, 1],
-                [0, 2],
-                [0, 3],
-            ],
-            [
-                [1, 1],
-                [2, 2],
-            ],
-            [[2, 1]],
-            [[1, 2]],
-            [[1, 3]],
-        ];
-        const choice = random(choices);
-        const firstVecIndex = randint(0, choice.length);
-        firstVecCoords = choice[firstVecIndex];
-        if (choice.length === 1) {
-            firstVecCoords = choice[0];
-            secondVecCoords = choice[0];
+        //!mama mia
+        //pardon au moi du futur
+        //en gros l'idée est qu'on construit deux paires de coordonnées de vecteurs colinéaires (ou non colinéaires) puis on boucle à l'infini sur les points pour trouver des points correspondants aux coordonnées des vecteurs choisis
+        let firstVecCoords, secondVecCoords;
+        const isColinear = coinFlip();
+        if (isColinear) {
+            const choices = [
+                [
+                    [1, 0],
+                    [2, 0],
+                ],
+                [
+                    [0, 1],
+                    [0, 2],
+                    [0, 3],
+                ],
+                [
+                    [1, 1],
+                    [2, 2],
+                ],
+                [[2, 1]],
+                [[1, 2]],
+                [[1, 3]],
+            ];
+            const choice = random(choices);
+            const firstVecIndex = randint(0, choice.length);
+            firstVecCoords = choice[firstVecIndex];
+            if (choice.length === 1) {
+                firstVecCoords = choice[0];
+                secondVecCoords = choice[0];
+                const reverseFirst = coinFlip();
+                if (reverseFirst)
+                    firstVecCoords = firstVecCoords.map((e) => -e);
+                else
+                    secondVecCoords = secondVecCoords.map((e) => -e);
+            }
+            else {
+                const secondVecIndex = randint(0, choice.length);
+                secondVecCoords = choice[secondVecIndex];
+                const mustReverseOne = secondVecIndex === firstVecIndex;
+                const willReverse = mustReverseOne || coinFlip();
+                if (willReverse) {
+                    const reverseFirst = coinFlip();
+                    if (reverseFirst)
+                        firstVecCoords = firstVecCoords.map((e) => -e);
+                    else
+                        secondVecCoords = secondVecCoords.map((e) => -e);
+                }
+            }
+        }
+        else {
+            //choix précédents + (2,3)
+            const choices = [
+                [
+                    [1, 0],
+                    [2, 0],
+                ],
+                [
+                    [0, 1],
+                    [0, 2],
+                    [0, 3],
+                ],
+                [
+                    [1, 1],
+                    [2, 2],
+                ],
+                [[2, 1]],
+                [[1, 2]],
+                [[1, 3]],
+                [[2, 3]],
+            ];
+            const firstChoiceIndex = randint(0, choices.length);
+            const secondChoiceIndex = randint(0, choices.length, [firstChoiceIndex]);
+            firstVecCoords = random(choices[firstChoiceIndex]);
+            secondVecCoords = random(choices[secondChoiceIndex]);
             const reverseFirst = coinFlip();
             if (reverseFirst)
                 firstVecCoords = firstVecCoords.map((e) => -e);
             else
                 secondVecCoords = secondVecCoords.map((e) => -e);
         }
-        else {
-            const secondVecIndex = randint(0, choice.length);
-            secondVecCoords = choice[secondVecIndex];
-            const mustReverseOne = secondVecIndex === firstVecIndex;
-            const willReverse = mustReverseOne || coinFlip();
-            if (willReverse) {
-                const reverseFirst = coinFlip();
-                if (reverseFirst)
-                    firstVecCoords = firstVecCoords.map((e) => -e);
-                else
-                    secondVecCoords = secondVecCoords.map((e) => -e);
+        // let firstVec, secondVec;
+        let counter = 0;
+        while (true) {
+            counter++;
+            if (counter > 1000)
+                throw new Error("Too many iterations in colFromPic");
+            const A = random(points);
+            const B = random(points);
+            if (B.x.evaluate() - A.x.evaluate() === firstVecCoords[0] &&
+                B.y.evaluate() - A.y.evaluate() === firstVecCoords[1]) {
+                firstVec = [A.toIdentifiers(), B.toIdentifiers()];
+                break;
             }
         }
-    }
-    else {
-        //choix précédents + (2,3)
-        const choices = [
-            [
-                [1, 0],
-                [2, 0],
-            ],
-            [
-                [0, 1],
-                [0, 2],
-                [0, 3],
-            ],
-            [
-                [1, 1],
-                [2, 2],
-            ],
-            [[2, 1]],
-            [[1, 2]],
-            [[1, 3]],
-            [[2, 3]],
-        ];
-        const firstChoiceIndex = randint(0, choices.length);
-        const secondChoiceIndex = randint(0, choices.length, [firstChoiceIndex]);
-        firstVecCoords = random(choices[firstChoiceIndex]);
-        secondVecCoords = random(choices[secondChoiceIndex]);
-        const reverseFirst = coinFlip();
-        if (reverseFirst)
-            firstVecCoords = firstVecCoords.map((e) => -e);
-        else
-            secondVecCoords = secondVecCoords.map((e) => -e);
-    }
-    let firstVec, secondVec;
+        let cnt = 0;
+        while (true) {
+            //!FIIIX
+            cnt++;
+            if (cnt > 1000)
+                throw new Error("Too many iterations in colFromPic");
+            const C = random(points);
+            const D = random(points);
+            if (D.x.evaluate() - C.x.evaluate() === secondVecCoords[0] &&
+                D.y.evaluate() - C.y.evaluate() === secondVecCoords[1]) {
+                secondVec = [C.toIdentifiers(), D.toIdentifiers()];
+                break;
+            }
+        }
+    };
     let counter = 0;
-    while (true) {
+    while (!isGenerationOk) {
         counter++;
-        if (counter > 1000)
+        if (counter > 100)
             throw new Error("Too many iterations in colFromPic");
-        const A = random(points);
-        const B = random(points);
-        if (B.x.evaluate() - A.x.evaluate() === firstVecCoords[0] &&
-            B.y.evaluate() - A.y.evaluate() === firstVecCoords[1]) {
-            firstVec = [A.toIdentifiers(), B.toIdentifiers()];
-            break;
+        try {
+            generate();
+            isGenerationOk = true;
         }
-    }
-    let cnt = 0;
-    while (true) {
-        //!FIIIX
-        cnt++;
-        if (cnt > 1000)
-            throw new Error("Too many iterations in colFromPic");
-        const C = random(points);
-        const D = random(points);
-        if (D.x.evaluate() - C.x.evaluate() === secondVecCoords[0] &&
-            D.y.evaluate() - C.y.evaluate() === secondVecCoords[1]) {
-            secondVec = [C.toIdentifiers(), D.toIdentifiers()];
-            break;
+        catch (_err) {
+            isGenerationOk = false;
         }
     }
     const identifiers = {
-        firstVec,
-        secondVec,
+        firstVec: firstVec,
+        secondVec: secondVec,
     };
     return getQuestionFromIdentifiers(identifiers);
 };

package/lib/exercises/math/geometry/vectors/vectorRepresentative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vectorRepresentative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/vectorRepresentative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAiMF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}
+{"version":3,"file":"vectorRepresentative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/vectorRepresentative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAkMF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}

package/lib/exercises/math/geometry/vectors/vectorRepresentative.js

@@ -24,11 +24,12 @@ const getPropositions = (_n, { vec, vecsProposed }) => {
     const vector = VectorConstructor.fromPoints(points.find((p) => p.name === vec[0]), points.find((p) => p.name === vec[1]));
     for (let i = 0; i < vecsProposed.length; i++) {
         const vecProp = VectorConstructor.fromPoints(points.find((p) => p.name === vecsProposed[i][0]), points.find((p) => p.name === vecsProposed[i][1]));
+        const tex = `\\overrightarrow{${vecsProposed[i]}}`;
         if (vector.equals(vecProp)) {
-            addValidProp(propositions, vecsProposed[i]);
+            addValidProp(propositions, tex);
         }
         else {
-            addWrongProp(propositions, vecsProposed[i]);
+            addWrongProp(propositions, tex);
         }
     }
     return propositions;