math-exercises 3.0.114 → 3.0.115

package/lib/exercises/math/geometry/angles/recognizeAngleType.d.ts

@@ -6,6 +6,9 @@ type Identifiers = {
     angleIndex: number;
     apexIndex: number;
 };
-export declare const recognizeAngleType: Exercise<Identifiers>;
+type Options = {
+    angleTypes: string[];
+};
+export declare const recognizeAngleType: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=recognizeAngleType.d.ts.map

package/lib/exercises/math/geometry/angles/recognizeAngleType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognizeAngleType.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/recognizeAngleType.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAUtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAmVF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}
+{"version":3,"file":"recognizeAngleType.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/recognizeAngleType.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAWtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA+SF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAeF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe7D,CAAC"}

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

@@ -1,4 +1,4 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { Angle } from "../../../../math/geometry/angle.js";
@@ -9,6 +9,7 @@ import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { random } from "../../../../utils/alea/random.js";
 import { randomLetter } from "../../../../utils/strings/randomLetter.js";
+import { reverseString } from "../../../../utils/strings/reverseString.js";
 const getAngle = (identifiers) => {
     const indexes = getAnglePointsIndexes(identifiers.angleIndex, identifiers.apexIndex);
     return new Angle(indexes.map((i) => PointConstructor.fromIdentifiers(identifiers.points[i])));
@@ -168,54 +169,13 @@ const isAnswerValid = (ans, { answer }) => {
         formated = formated.replaceAll("\\widehat{", "").replaceAll("}", "");
     }
     //TODO fix vea
-    return "\\widehat{" + formated + "}" === answer;
-    // let validAngles: string[] = [answer];
-    // switch (angleType) {
-    //   case "opposé par le sommet":
-    //   // return studentAngle.isSummitOpposite(answerAngle);
-    //   case "alterne-interne":
-    //     // return studentAngle.isAlterneInterne(answerAngle);
-    //     break;
-    //   case "correspondant":
-    //   default:
-    //     // return studentAngle.isCorrespondant(answerAngle);
-    //     break;
-    // }
-    // return validAngles.includes(formated);
-    // let formated = ans;
-    // if (ans.includes("widehat")) {
-    //   formated = formated.replaceAll("\\widehat{", "").replaceAll("}", "");
-    // }
-    // const pointsNames = Array.from(new Set(formated.split("")));
-    // if (pointsNames.length !== 3 || pointsNames.some((char) => !isLetter(char)))
-    //   return false;
-    // const studentPoints = pointsNames.map((char) =>
-    //   PointConstructor.fromIdentifiers(points.find((p) => p.name === char)!),
-    // );
-    // const answerAngle = getAngle({ angleIndex, apexIndex, points });
-    // const studentAngle = new Angle(studentPoints);
-    // //? on va accpter aussi des angles correspondants ou alternes-internes qui ne sont pas définis par les sécantes tracées
-    // //? c'est chelou mais dans le fond ça fait sens (c'est vrai mathémtiquement)
-    // switch (angleType) {
-    //   case "opposé par le sommet":
-    //     return studentAngle.isSummitOpposite(answerAngle);
-    //   case "alterne-interne":
-    //     return studentAngle.isAlterneInterne(answerAngle);
-    //     break;
-    //   case "correspondant":
-    //   default:
-    //     return studentAngle.isCorrespondant(answerAngle);
-    //     break;
-    // }
-    return false;
+    return ("\\widehat{" + formated + "}" === answer ||
+        "\\widehat{" + reverseString(formated) + "}" === answer);
 };
 //deux paires de sécantes
-const getRecognizeAngleTypeQuestion = () => {
-    const angleType = random([
-        "alterne-interne",
-        "correspondant",
-        "opposé par le sommet",
-    ]);
+const getRecognizeAngleTypeQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const angleType = random(opts.angleTypes);
     const names = [];
     for (let i = 0; i < 12; i++) {
         names.push(randomLetter(true, names));
@@ -273,11 +233,25 @@ const getQuestionFromIdentifiers = (identifiers) => {
     };
     return question;
 };
+const optsDefault = {
+    angleTypes: ["alterne-interne", "correspondant", "opposé par le sommet"],
+};
+const options = [
+    {
+        id: "angleTypes",
+        label: "Type d'angles demandés",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["alterne-interne", "correspondant", "opposé par le sommet"],
+        defaultValue: optsDefault.angleTypes,
+    },
+];
 export const recognizeAngleType = {
     id: "recognizeAngleType",
     label: "Reconnaître un angle alterne-interne, correspondant, opposé par le sommet",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getRecognizeAngleTypeQuestion(opts), nb),
+    options,
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,

package/lib/exercises/math/primitive/polynomialPrimitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/polynomialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAiBF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAKjE,CAAC;AAEF,eAAO,MAAM,6CAA6C,EAAE,0BAA0B,CACpF,WAAW,CAYZ,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAexE,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CA2B7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAYrD,CAAC"}
+{"version":3,"file":"polynomialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/polynomialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAiBF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAKjE,CAAC;AAEF,eAAO,MAAM,6CAA6C,EAAE,0BAA0B,CACpF,WAAW,CAYZ,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAexE,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CA8B7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAYrD,CAAC"}

package/lib/exercises/math/primitive/polynomialPrimitive.js

@@ -46,12 +46,12 @@ export const getPolynomialPrimitivePropositions = (n, { answer, coeffs }) => {
     }
     return shuffle(propositions);
 };
-export const isPolynomialPrimitiveAnswerValid = (ans) => {
+export const isPolynomialPrimitiveAnswerValid = (ans, { answer }) => {
     try {
         const parsed = parseAlgebraic(ans);
         if (!parsed)
             return false;
-        const ansParsed = parseAlgebraic(ans);
+        const ansParsed = parseAlgebraic(answer);
         return (parsed
             .simplify({
             towardsDistribute: true,

package/lib/exercises/math/probaStat/basicProbas/possibleValuesForProba.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    arrayOfNodeIds: NodeIdentifiers[];
+    isFilterPossibleProba: boolean;
+};
+type Options = {
+    numberTypes: string[];
+    nbValues: number;
+};
+export declare const possibleValuesForProba: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=possibleValuesForProba.d.ts.map

package/lib/exercises/math/probaStat/basicProbas/possibleValuesForProba.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"possibleValuesForProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/possibleValuesForProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAa7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC;AAkHF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAgNF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBjE,CAAC"}

package/lib/exercises/math/probaStat/basicProbas/possibleValuesForProba.js

@@ -0,0 +1,293 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseLatex } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getAnswer = (identifiers) => {
+    const { arrayOfNodeIds, isFilterPossibleProba } = identifiers;
+    const arrayOfPossibleProbas = arrayOfNodeIds
+        .map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds))
+        .filter((node) => {
+        return isFilterPossibleProba
+            ? node.evaluate() >= 0 && substract(node, 1).evaluate() <= 0
+            : node.evaluate() < 0 || substract(node, 1).evaluate() > 0;
+    })
+        .toSorted((nodeA, nodeB) => substract(nodeA, nodeB).evaluate());
+    const answer = arrayOfPossibleProbas.map((node) => node.toTex()).join(";");
+    return answer;
+};
+const getInstruction = (identifiers) => {
+    const { arrayOfNodeIds, isFilterPossibleProba } = identifiers;
+    const arrNode = arrayOfNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Parmi les valeurs de la liste ci-dessous, donner celles qui sont des valeurs ${isFilterPossibleProba ? "possibles" : "impossibles"} pour une probabilité
+(séparer les valeurs par des points-virgules) : 
+$$
+${arrNode.map((node) => node.toTex()).join(" \\hspace{2mm} ; \\hspace{2mm} ")}
+$$
+`;
+};
+const getHint = () => {
+    return "Une probabilité est toujours comprise entre $0\\%$ et $100\\%$.";
+};
+const getCorrection = (identifiers) => {
+    return `Les valeurs possibles pour une probabilité sont comprises entre $0$ inclus et $1$ inclus.
+La liste à constituer était donc : 
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { arrayOfNodeIds, isFilterPossibleProba } = identifiers;
+    const propositions = [];
+    // addValidProp(propositions, answer);
+    const allProbas = arrayOfNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const possibleNodes = allProbas.filter((node) => node.evaluate() >= 0 && substract(node, 1).evaluate() <= 0);
+    const impossibleNodes = allProbas.filter((node) => node.evaluate() < 0 || substract(node, 1).evaluate() > 0);
+    const validNodes = isFilterPossibleProba ? possibleNodes : impossibleNodes;
+    //we keep the order of the question
+    addValidProp(propositions, validNodes.map((node) => node.toTex()).join(" ; "));
+    while (propositions.length < n) {
+        const pickedNodes = allProbas.filter(coinFlip);
+        tryToAddWrongProp(propositions, pickedNodes.map((node) => node.toTex()).join(" ; "));
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const ansWithoutTrailingSemicolon = ans.slice(-1) === ";" ? ans.slice(0, -1) : ans;
+    const arrTex = ansWithoutTrailingSemicolon.split(";");
+    const arrNode = arrTex
+        .map((tex) => parseLatex(tex))
+        .toSorted((nodeA, nodeB) => substract(nodeA, nodeB).evaluate());
+    const arrTexSorted = arrNode.map((node) => node.toTex());
+    const ansRefined = arrTexSorted.join(";");
+    return ansRefined === answer;
+};
+const getKeys = (identifiers) => {
+    const { arrayOfNodeIds } = identifiers;
+    const arrNode = arrayOfNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return [
+        "semicolon",
+        ...arrNode.map((node) => {
+            return {
+                id: "custom",
+                label: node.toTex(),
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: node.toTex(),
+                },
+            };
+        }),
+    ];
+};
+const optsDefault = {
+    numberTypes: ["Entier", "Décimal", "Fraction", "Puiss10", "Sci", "Réel"],
+    nbValues: 8,
+};
+const options = [
+    {
+        id: "numberTypes",
+        label: "Types de nombres",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["Entier", "Décimal", "Fraction", "Puiss10", "Sci", "Réel"],
+        defaultValue: optsDefault.numberTypes,
+    },
+    {
+        id: "nbValues",
+        label: "Longueur de la liste",
+        type: GeneratorOptionType.select,
+        target: GeneratorOptionTarget.generation,
+        values: [5, 6, 7, 8, 9, 10],
+        defaultValue: optsDefault.nbValues,
+    },
+];
+const createRandomNode = (numberType, isPossibleProba) => {
+    if (isPossibleProba) {
+        switch (numberType) {
+            case "Décimal":
+                return randfloat(0, 1, randint(1, 7)).toTree();
+            case "Fraction": {
+                if (probaFlip(0.7)) {
+                    const num = randint(0, 10_000);
+                    const den = randint(num, 20_000);
+                    return frac(num, den);
+                }
+                else {
+                    const num = randfloat(0, 100, randint(1, 3));
+                    const den = randfloat(100, 200, randint(1, 3));
+                    return frac(num, den);
+                }
+            }
+            case "Puiss10":
+                return power(10, randint(-15, 1));
+            case "Sci":
+                if (probaFlip(0.7)) {
+                    return multiply(randfloat(1, 10, randint(1, 5)), power(10, randint(-15, 0)));
+                }
+                else {
+                    return multiply(randint(1, 10), power(10, randint(-15, 0)));
+                }
+            case "Réel":
+                return random([
+                    frac(PiNode, randint(4, 14)),
+                    sin(randfloat(0, PiNode.value, 2)),
+                    cos(randfloat(-frac(PiNode, 2).evaluate(), frac(PiNode, 2).evaluate(), 2)),
+                    exp(randint(-10, 0)),
+                    sqrt(randfloat(0, 1)),
+                ]);
+            case "Entier":
+            default:
+                return randint(0, 2).toTree();
+        }
+    }
+    else {
+        switch (numberType) {
+            case "Décimal":
+                return coinFlip()
+                    ? randfloat(-100, 0, randint(1, 7), [0]).toTree()
+                    : randfloat(1, 100, randint(1, 7), [1]).toTree();
+            case "Fraction": {
+                if (probaFlip(0.7)) {
+                    const num = coinFlip()
+                        ? randint(10_000, 20_000)
+                        : randint(-20_000, -10_000);
+                    const den = randint(0, abs(num).evaluate());
+                    return frac(num, den);
+                }
+                else {
+                    const num = coinFlip()
+                        ? randfloat(1, 200, randint(1, 3), [1])
+                        : randfloat(-200, -1, randint(1, 3));
+                    const den = randfloat(1, abs(num).evaluate(), randint(1, 3));
+                    return frac(num, den);
+                }
+            }
+            case "Puiss10":
+                return power(10, randint(1, 15));
+            case "Sci":
+                if (probaFlip(0.7)) {
+                    return coinFlip()
+                        ? multiply(randfloat(1, 10, randint(1, 5), [1]), power(10, randint(0, 15)))
+                        : multiply(randfloat(-10, -1, randint(1, 5), [-10]), power(10, randint(0, 15)));
+                }
+                else {
+                    return coinFlip()
+                        ? multiply(randint(2, 10), power(10, randint(0, 15)))
+                        : multiply(randint(-10, -1, [-10]), power(10, randint(0, 15)));
+                }
+            case "Réel":
+                return random([
+                    PiNode,
+                    frac(PiNode, randint(2, 4)),
+                    exp(randint(1, 10)),
+                    sqrt(randfloat(1, 100, randint(1, 5), [1])),
+                ]);
+            case "Entier":
+            default:
+                return randint(-100, 100, [0, 1]).toTree();
+        }
+    }
+};
+const getPossibleValuesForProbaQuestion = (optsIn) => {
+    const opts = Object.assign(optsDefault, optsIn) ?? optsDefault;
+    const isFilterPossibleProba = coinFlip();
+    //create numberType list
+    const dictNumberTypeToPriority = {
+        Entier: 1,
+        Puiss10: 2,
+        Décimal: 3,
+        Fraction: 4,
+        Réel: 5,
+    };
+    let arrNumberType = [...opts.numberTypes];
+    //filler
+    while (arrNumberType.length < opts.nbValues) {
+        arrNumberType.push(...shuffle(opts.numberTypes));
+    }
+    arrNumberType = arrNumberType
+        .slice(0, opts.nbValues)
+        .toSorted((numberType1, numberType2) => dictNumberTypeToPriority[numberType1] -
+        dictNumberTypeToPriority[numberType2]);
+    //create list
+    let arrNode = [];
+    const arrIsPossibleProba = [];
+    let is0And1AlreadyPicked = false;
+    for (let i = 0; i < arrNumberType.length; i++) {
+        const numberType = arrNumberType[i];
+        //ensure answer is neither an empty list, nor the whole list
+        const isLast = i === arrNumberType.length - 1;
+        const isPossibleProba = numberType === "Entier" && is0And1AlreadyPicked
+            ? false
+            : isLast &&
+                (arrIsPossibleProba.every((b) => b) ||
+                    arrIsPossibleProba.every((b) => !b))
+                ? !arrIsPossibleProba[0]
+                : coinFlip();
+        arrIsPossibleProba.push(isPossibleProba);
+        //ensure distinct values
+        let nodeCandidate;
+        let isAlreadyInList = true;
+        do {
+            nodeCandidate = createRandomNode(numberType, isPossibleProba);
+            isAlreadyInList = arrNode
+                .map((node) => node.evaluate())
+                .includes(nodeCandidate.evaluate());
+        } while (isAlreadyInList);
+        arrNode.push(nodeCandidate);
+        is0And1AlreadyPicked ||=
+            arrNode.map((node) => node.evaluate()).filter((v) => v === 0 || v === 1)
+                .length === 2;
+    }
+    arrNode = shuffle(arrNode);
+    const identifiers = {
+        arrayOfNodeIds: arrNode.map((node) => node.toIdentifiers()),
+        isFilterPossibleProba,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const possibleValuesForProba = {
+    id: "possibleValuesForProba",
+    label: "Déterminer les valeurs possibles pour une probabilité",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPossibleValuesForProbaQuestion(opts), nb, 30),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    hasHintAndCorrection: true,
+};

package/lib/index.d.ts

@@ -1706,7 +1706,9 @@ declare const mathExercises: (Exercise<{
     angleType: string;
     angleIndex: number;
     apexIndex: number;
-}, object, string | number | boolean | string[]> | Exercise<{
+}, {
+    angleTypes: string[];
+}, string | number | boolean | string[]> | Exercise<{
     doubleAngle: number;
     singleAngle: number;
 }, object, string | number | boolean | string[]> | Exercise<{

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDAA6B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/tests/questionTest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAIjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CAiO3B,CAAC"}
+{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAIjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CAuO3B,CAAC"}

package/lib/tests/questionTest.js

@@ -130,6 +130,8 @@ export const questionTest = (exo, question) => {
     //     };
     //   }
     // }
+    if (exo.answerType !== "QCM" && exo.isQCM)
+        throw new Error("exo " + exo.id + " has isQCM but answerType is not QCM");
     if (exo.answerType !== "QCM" &&
         exo.answerType !== "QCU" &&
         exo.answerType !== "GGB" &&
@@ -152,6 +154,8 @@ export const questionTest = (exo, question) => {
         exo.answerType !== "valueTable" &&
         exo.answerType !== "varTable" &&
         exo.answerType !== "signTable") {
+        if (exo.answerType === "QCM" && !exo.isQCM)
+            throw new Error("exo " + exo.id + " has answerType QCM but not isQCM");
         const before = Date.now();
         console.log("will generate props : ", exo.id, "ids :", question.identifiers);
         const props = exo.getPropositions(4, {

package/lib/utils/strings/reverseString.d.ts

@@ -0,0 +1,2 @@
+export declare const reverseString: (str: string) => string;
+//# sourceMappingURL=reverseString.d.ts.map

package/lib/utils/strings/reverseString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverseString.d.ts","sourceRoot":"","sources":["../../../src/utils/strings/reverseString.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,KAAG,MAE3C,CAAC"}

package/lib/utils/strings/reverseString.js

@@ -0,0 +1,3 @@
+export const reverseString = (str) => {
+    return str.split('').reverse().join('');
+};

package/package.json

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