math-exercises 3.0.156 → 3.0.158

package/lib/exercises/math/trigonometry/triangle/trigonometrySohcahtoaUse.js

@@ -0,0 +1,386 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { RightTriangleConstructor } from "../../../../math/geometry/triangles/rightTriangle.js";
+import { TriangleConstructor, } from "../../../../math/geometry/triangles/triangle.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { getAllPicks } from "../../../../utils/arrays/getAllPicks.js";
+const trigoFuncsDict = {
+    sin: {
+        id: "sin",
+        strFrench: "sinus",
+        funcTex: (content) => `\\sin(${content})`,
+        funcIndexesSegment: (indexPoint) => {
+            switch (indexPoint) {
+                case 1:
+                    return [1, 0];
+                case 2:
+                    return [2, 0];
+                default:
+                    throw new Error("Unsupported indexPoint: " + indexPoint);
+            }
+        },
+        texEqFrac: "\\sin(\\text{angle}) = \\frac{\\text{opposé}}{\\text{hypoténuse}}",
+    },
+    cos: {
+        id: "cos",
+        strFrench: "cosinus",
+        funcTex: (content) => `\\cos(${content})`,
+        funcIndexesSegment: (indexPoint) => {
+            switch (indexPoint) {
+                case 1:
+                    return [2, 0];
+                case 2:
+                    return [1, 0];
+                default:
+                    throw new Error("Unsupported indexPoint: " + indexPoint);
+            }
+        },
+        texEqFrac: "\\cos(\\text{angle}) = \\frac{\\text{adjacent}}{\\text{hypoténuse}}",
+    },
+    tan: {
+        id: "tan",
+        strFrench: "tangente",
+        funcTex: (content) => `\\tan(${content})`,
+        funcIndexesSegment: (indexPoint) => {
+            switch (indexPoint) {
+                case 1:
+                    return [1, 2];
+                case 2:
+                    return [2, 1];
+                default:
+                    throw new Error("Unsupported indexPoint: " + indexPoint);
+            }
+        },
+        texEqFrac: "\\tan(\\text{angle}) = \\frac{\\text{opposé}}{\\text{adjacent}}",
+    },
+};
+const getTrigoFuncEntryForTargetAngle = (indexTarget, indexesGivenSegments) => {
+    return Object.entries(trigoFuncsDict).find(([_, trigoFunc]) => {
+        const indexesSegment = trigoFunc.funcIndexesSegment(indexTarget);
+        return ([...new Set([...indexesSegment, ...indexesGivenSegments])].length === 2);
+    });
+};
+const getTrigoFuncEntryForTargetSide = (indexTarget, indexGivenSegment, indexGivenAngle) => {
+    return Object.entries(trigoFuncsDict).find(([_, trigoFunc]) => {
+        const indexesSegment = trigoFunc.funcIndexesSegment(indexGivenAngle);
+        return ([...new Set([...indexesSegment, ...[indexTarget, indexGivenSegment]])]
+            .length === 2);
+    });
+};
+const getTrigoFuncAndIndexesSegmentDict = (targetType, indexTarget, indexesGivenSegments, indexGivenAngle) => {
+    let trigoFunc;
+    let indexesSegment;
+    switch (targetType) {
+        case "angle":
+            {
+                [, trigoFunc] = getTrigoFuncEntryForTargetAngle(indexTarget, indexesGivenSegments);
+                indexesSegment = trigoFunc.funcIndexesSegment(indexTarget);
+            }
+            break;
+        case "segment":
+            {
+                [, trigoFunc] = getTrigoFuncEntryForTargetSide(indexTarget, indexesGivenSegments[0], indexGivenAngle);
+                indexesSegment = trigoFunc.funcIndexesSegment(indexGivenAngle);
+            }
+            break;
+    }
+    return { trigoFunc, indexesSegment };
+};
+const getInstruction = (identifiers) => {
+    const { targetType, indexTarget, triangleIdentifiers, indexesGivenSegments, indexGivenAngle, } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    switch (identifiers.questionType) {
+        case "frac":
+            {
+                switch (targetType) {
+                    case "angle": {
+                        const texAngle = `\\widehat{${triangle.points[indexTarget].toTex()}}`;
+                        return `Dans le triangle $${triangle.name}$ ci-dessous, on connaît la longueur $${triangle.sides[indexesGivenSegments[0]].toInsideName()}$ et la longueur $${triangle.sides[indexesGivenSegments[1]].toInsideName()}$. Quel rapport trigonométrique doit-on utiliser pour calculer la mesure de $${texAngle}$ ?`;
+                    }
+                    case "segment": {
+                        return `Dans le triangle $${triangle.name}$ ci-dessous, on connaît la longueur $${triangle.sides[indexesGivenSegments[0]].toInsideName()}$ et la mesure de l'angle $\\widehat{${triangle.points[indexGivenAngle].toTex()}}$. Quel rapport trigonométrique doit-on utiliser pour calculer la longueur $${triangle.sides[indexTarget].toInsideName()}$ ?`;
+                    }
+                }
+            }
+            break;
+        case "func": {
+            switch (targetType) {
+                case "angle": {
+                    const texAngle = `\\widehat{${triangle.points[indexTarget].toTex()}}`;
+                    return `Dans le triangle $${triangle.name}$ ci-dessous, on connaît la longueur $${triangle.sides[indexesGivenSegments[0]].toInsideName()}$ et la longueur $${triangle.sides[indexesGivenSegments[1]].toInsideName()}$. Quelle fonction trigonométrique doit-on utiliser pour calculer la mesure de $${texAngle}$ ?`;
+                }
+                case "segment": {
+                    return `Dans le triangle $${triangle.name}$ ci-dessous, on connaît la longueur $${triangle.sides[indexesGivenSegments[0]].toInsideName()}$ et la mesure de l'angle $\\widehat{${triangle.points[indexGivenAngle].toTex()}}$. Quelle fonction trigonométrique doit-on utiliser pour calculer la longueur $${triangle.sides[indexTarget].toInsideName()}$ ?`;
+                }
+            }
+        }
+    }
+};
+const getAnswerNode = (identifiers) => {
+    const { targetType, indexTarget, indexGivenAngle, indexesGivenSegments, triangleIdentifiers, } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    let indexesSegment;
+    switch (targetType) {
+        case "angle":
+            {
+                const [, trigoFunc] = getTrigoFuncEntryForTargetAngle(indexTarget, indexesGivenSegments);
+                indexesSegment = trigoFunc.funcIndexesSegment(indexTarget);
+            }
+            break;
+        case "segment":
+            {
+                const [, trigoFunc] = getTrigoFuncEntryForTargetSide(indexTarget, indexesGivenSegments[0], indexGivenAngle);
+                indexesSegment = trigoFunc.funcIndexesSegment(indexGivenAngle);
+            }
+            break;
+    }
+    const [nodeNum, nodeDen] = indexesSegment.map((indexSegment) => new VariableNode(`${triangle.sides[indexSegment].toInsideName()}`));
+    const fractionNode = frac(nodeNum, nodeDen);
+    return fractionNode;
+};
+const getAnswer = (identifiers) => {
+    switch (identifiers.questionType) {
+        case "frac": {
+            return getAnswerNode(identifiers).toTex();
+        }
+        case "func": {
+            const { targetType, indexTarget, indexGivenAngle, indexesGivenSegments } = identifiers;
+            const { trigoFunc } = getTrigoFuncAndIndexesSegmentDict(targetType, indexTarget, indexesGivenSegments, indexGivenAngle);
+            const nameTrigoFunc = trigoFunc.id;
+            const tex = `\\text{${nameTrigoFunc}}`;
+            return tex;
+        }
+    }
+};
+const getHint = () => {
+    return `Identifie le côté opposé, le côté adjacent et l'hypoténuse du triangle. Puis cherche la bonne formule de trigonométrie, en te rappelant de : 
+  
+$$
+\\text{SOHCAHTOA}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { targetType, indexTarget, indexGivenAngle, indexesGivenSegments, triangleIdentifiers, } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const { trigoFunc, indexesSegment } = getTrigoFuncAndIndexesSegmentDict(targetType, indexTarget, indexesGivenSegments, indexGivenAngle);
+    const [segmentNum, segmentDen] = indexesSegment.map((i) => triangle.sides[i]);
+    const [nameNum, nameDen] = [segmentNum, segmentDen].map((segment) => `${segment.pointA.name}${segment.pointB.name}`);
+    const texAngle = `\\widehat{${triangle.points[indexGivenAngle ?? indexTarget].toTex()}}`;
+    return `On a :
+  
+$$
+${trigoFunc.funcTex(texAngle)} = \\frac{${nameNum}}{${nameDen}}
+$$
+
+${(() => {
+        switch (identifiers.questionType) {
+            case "frac": {
+                return `Le rapport recherché est $${`\\frac{${nameNum}}{${nameDen}}`}$.`;
+            }
+            case "func": {
+                return `La fonction recherchée est la fonction ${trigoFunc.strFrench}.`;
+            }
+        }
+    })()}`;
+};
+const getGGBOptions = (identifiers) => {
+    const { targetType, indexTarget, indexGivenAngle, indexesGivenSegments, triangleIdentifiers, } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    switch (targetType) {
+        case "angle":
+            {
+                //target
+                triangle.highlightAngle(indexTarget, {
+                    color: blueMain,
+                    showValue: false,
+                });
+                //given
+                indexesGivenSegments.forEach((indexSegment) => {
+                    triangle.highlightSide(indexSegment, { color: red });
+                });
+            }
+            break;
+        case "segment":
+            {
+                //target
+                triangle.highlightSide(indexTarget, {
+                    color: blueMain,
+                });
+                //given
+                if (indexGivenAngle) {
+                    triangle.highlightAngle(indexGivenAngle, {
+                        color: red,
+                        showValue: false,
+                    });
+                }
+                indexesGivenSegments.forEach((indexSegment) => {
+                    triangle.highlightSide(indexSegment, { color: red });
+                });
+            }
+            break;
+    }
+    const ggb = new GeogebraConstructor({
+        commands: triangle.commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    switch (identifiers.questionType) {
+        case "frac": {
+            const { triangleIdentifiers } = identifiers;
+            const propositions = [];
+            const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+            addValidProp(propositions, answer);
+            getAllPicks([0, 1, 2])
+                .filter((arrSegment) => arrSegment.length === 2)
+                .forEach((indexesSegment) => {
+                const [nodeNum, nodeDen] = indexesSegment.map((indexSegment) => new VariableNode(`${triangle.sides[indexSegment].toInsideName()}`));
+                const fractionNode1 = frac(nodeNum, nodeDen);
+                tryToAddWrongProp(propositions, fractionNode1.toTex());
+                const fractionNode2 = frac(nodeDen, nodeNum);
+                tryToAddWrongProp(propositions, fractionNode2.toTex());
+            });
+            return shuffleProps(propositions, n);
+        }
+        case "func": {
+            const propositions = [];
+            ["sin", "cos", "tan"].forEach((nameTrigoFunc) => {
+                const tex = `\\text{${nameTrigoFunc}}`;
+                if (tex === answer) {
+                    addValidProp(propositions, tex);
+                }
+                else {
+                    tryToAddWrongProp(propositions, tex);
+                }
+            });
+            return shuffle(propositions);
+        }
+    }
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getKeys = (identifiers) => {
+    switch (identifiers.questionType) {
+        case "frac": {
+            const { triangleIdentifiers } = identifiers;
+            const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+            return [
+                ...triangle.sides.map((side) => {
+                    const strLength = side.toInsideName();
+                    return {
+                        id: "custom",
+                        label: strLength,
+                        labelType: "tex",
+                        mathfieldInstructions: {
+                            method: "write",
+                            content: strLength,
+                        },
+                    };
+                }),
+            ];
+        }
+        case "func": {
+            return ["sin", "cos", "tan"];
+        }
+    }
+};
+const getTrigonometrySohcahtoaUseQuestion = (optsIn) => {
+    const targetTypes = optsIn?.targetTypes ?? optsDefault.targetTypes;
+    const opts = Object.assign(optsIn, { targetTypes });
+    const triangle = RightTriangleConstructor.randomNiceSides({
+        randomName: true,
+    });
+    const targetType = random(targetTypes);
+    const indexTarget = randint(1, 3);
+    let indexGivenAngle;
+    const indexesGivenSegments = [];
+    switch (targetType) {
+        case "angle":
+            {
+                indexesGivenSegments.push(...randomMany([0, 1, 2], 2));
+            }
+            break;
+        case "segment":
+            {
+                indexGivenAngle = randint(1, 3);
+                indexesGivenSegments.push(3 - indexTarget);
+            }
+            break;
+    }
+    const identifiers = {
+        questionType: opts.questionType,
+        targetType,
+        indexTarget,
+        indexGivenAngle,
+        indexesGivenSegments,
+        triangleIdentifiers: triangle.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        options: opts,
+    };
+};
+const optsDefault = {
+    targetTypes: ["angle", "segment"],
+};
+const options = [
+    {
+        id: "targetType",
+        label: "Mesure recherchée",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["angle", "segment"],
+        defaultValue: optsDefault.targetTypes,
+    },
+];
+export const trigonometrySohcahtoaUseFrac = {
+    id: "trigonometrySohcahtoaUseFrac",
+    label: "Utiliser le bon rapport trigonométrique pour calculer la mesure d'un angle ou d'un segment",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrigonometrySohcahtoaUseQuestion(Object.assign({}, { questionType: "frac" }, opts)), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};
+export const trigonometrySohcahtoaUseFunc = {
+    id: "trigonometrySohcahtoaUseFunc",
+    label: "Utiliser la bonne fonction trigonométrique pour calculer la mesure d'un angle ou d'un segment",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrigonometrySohcahtoaUseQuestion(Object.assign({}, { questionType: "func" }, opts)), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+};

package/lib/exercises/math/trigonometry/trigonometrySideCalcul.js

@@ -14,7 +14,7 @@ const getInstruction = (identifiers) => {
     const angleValue = triangle.angles[givenAngle].evaluate().frenchify();
     return `Le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$ est tel que $${triangle.sides[givenSide].toLengthTex()}\\ \\textrm{cm}$ et $${triangle.angles[givenAngle].toTex()} = ${angleValue}^\\circ$. 
     
-Calculer $${triangle.sides[sideAsked].toInsideName()}$ à $0,1 \\ \\textrm{cm}$.`;
+Calculer $${triangle.sides[sideAsked].toInsideName()}$ à $0,1 \\ \\textrm{cm}$ près.`;
 };
 const getAnswer = (identifiers) => {
     const { sideAsked, triangleIdentifiers } = identifiers;

package/lib/exercises/pc/mathExosInPC.d.ts

@@ -25,6 +25,6 @@ export * from "../math/derivation/derivative/polynomial/usualderivative.js";
 export { thirdDegreeDerivative } from "../math/derivation/derivative/polynomial/thirdDegreeDerivative.js";
 export { firstDegreeDerivative } from "../math/derivation/derivative/polynomial/firstDegreeDerivative.js";
 export { secondDegreeDerivative } from "../math/derivation/derivative/polynomial/secondDegreeDerivative.js";
-export * from "../math/trigonometry/trigonometrySideCalcul.js";
-export * from "../math/trigonometry/trigonometryAngleCalcul.js";
+export * from "../math/trigonometry/triangle/trigonometrySideCalcul.js";
+export * from "../math/trigonometry/triangle/trigonometryAngleCalcul.js";
 //# sourceMappingURL=mathExosInPC.d.ts.map

package/lib/exercises/pc/mathExosInPC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mathExosInPC.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/mathExosInPC.ts"],"names":[],"mappings":"AAAA,yBAAyB;AACzB,cAAc,mCAAmC,CAAC;AAClD,cAAc,wDAAwD,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,cAAc,uCAAuC,CAAC;AACtD,cAAc,gDAAgD,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AACrF,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,kEAAkE,CAAC;AACjF,cAAc,+DAA+D,CAAC;AAC9E,cAAc,gDAAgD,CAAC;AAC/D,cAAc,sDAAsD,CAAC;AACrE,cAAc,mCAAmC,CAAC;AAClD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qDAAqD,CAAC;AACpE,cAAc,0CAA0C,CAAC;AACzD,cAAc,2DAA2D,CAAC;AAC1E,cAAc,uDAAuD,CAAC;AACtE,cAAc,6DAA6D,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,sBAAsB,EAAE,MAAM,oEAAoE,CAAC;AAC5G,cAAc,gDAAgD,CAAC;AAC/D,cAAc,iDAAiD,CAAC"}
+{"version":3,"file":"mathExosInPC.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/mathExosInPC.ts"],"names":[],"mappings":"AAAA,yBAAyB;AACzB,cAAc,mCAAmC,CAAC;AAClD,cAAc,wDAAwD,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,cAAc,uCAAuC,CAAC;AACtD,cAAc,gDAAgD,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AACrF,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,kEAAkE,CAAC;AACjF,cAAc,+DAA+D,CAAC;AAC9E,cAAc,gDAAgD,CAAC;AAC/D,cAAc,sDAAsD,CAAC;AACrE,cAAc,mCAAmC,CAAC;AAClD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qDAAqD,CAAC;AACpE,cAAc,0CAA0C,CAAC;AACzD,cAAc,2DAA2D,CAAC;AAC1E,cAAc,uDAAuD,CAAC;AACtE,cAAc,6DAA6D,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,sBAAsB,EAAE,MAAM,oEAAoE,CAAC;AAC5G,cAAc,yDAAyD,CAAC;AACxE,cAAc,0DAA0D,CAAC"}

package/lib/exercises/pc/mathExosInPC.js

@@ -25,5 +25,5 @@ export * from "../math/derivation/derivative/polynomial/usualderivative.js";
 export { thirdDegreeDerivative } from "../math/derivation/derivative/polynomial/thirdDegreeDerivative.js";
 export { firstDegreeDerivative } from "../math/derivation/derivative/polynomial/firstDegreeDerivative.js";
 export { secondDegreeDerivative } from "../math/derivation/derivative/polynomial/secondDegreeDerivative.js";
-export * from "../math/trigonometry/trigonometrySideCalcul.js";
-export * from "../math/trigonometry/trigonometryAngleCalcul.js";
+export * from "../math/trigonometry/triangle/trigonometrySideCalcul.js";
+export * from "../math/trigonometry/triangle/trigonometryAngleCalcul.js";

package/lib/exercises/vea/setVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/setVEA.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,8BAAsB,MAAM;IAC1B,MAAM,CAAC,mBAAmB,GACxB,QAAQ,aAAa,EAAE,EACvB,WAAW,aAAa,EAAE,aA2B1B;CACH"}
+{"version":3,"file":"setVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/setVEA.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,8BAAsB,MAAM;IAC1B,MAAM,CAAC,mBAAmB,GACxB,QAAQ,aAAa,EAAE,EACvB,WAAW,aAAa,EAAE,aAiC1B;CACH"}

package/lib/exercises/vea/setVEA.js

@@ -1,6 +1,10 @@
 import { isNodesEqual } from "./isNodesEqual.js";
 export class SetVEA {
     static isArrayOfNodesValid = (arrAns, arrAnswer) => {
+        const isSameLength = arrAns.length === arrAnswer.length;
+        if (!isSameLength) {
+            return false;
+        }
         const dictAnswer = Object.fromEntries(arrAnswer.map((node, i) => [i, node]));
         let isValid = true;
         for (let i = 0; i < arrAns.length; i++) {

package/lib/index.d.ts

@@ -464,7 +464,9 @@ declare const mathExercises: (Exercise<{
     b: number;
     c: number;
     d: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    answerInputTypes: string[];
+}> | Exercise<{
     a: number;
     b: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -499,7 +501,9 @@ declare const mathExercises: (Exercise<{
     a: number;
     isSum: boolean;
     b: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    answerInputTypes: string[];
+}> | Exercise<{
     problemSkeletonIndex: number;
     groupNameToVarNameToValue: Record<string, Record<string, import("./tree/nodes/algebraicNode.js").AlgebraicNode>>;
     mysteryVarPath: string;
@@ -953,6 +957,17 @@ declare const mathExercises: (Exercise<{
     coeffs: number[];
     x: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    faIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    fbIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    fxIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {
+    functionType: string[];
+}> | Exercise<{
     abscisse: number;
     trinome: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -2531,7 +2546,9 @@ declare const mathExercises: (Exercise<{
     pAB?: number;
     pA_B?: number;
     pB_A?: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    probaType: string[];
+}> | Exercise<{
     A: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     B: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     AC: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
@@ -2650,6 +2667,16 @@ declare const mathExercises: (Exercise<{
     pA: number;
     pB: number;
     pUnion: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pAIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    pBIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    pABIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pAIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    pBIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pAIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    pBIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     questionType: string;
     value?: string;
@@ -2805,6 +2832,11 @@ declare const mathExercises: (Exercise<{
     xValues: number[];
     yValues: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     atLeastXIndex: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    items: {
+        value: number;
+        indexColor: number;
+    }[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     indexSituation: number;
     eventIds: {
@@ -2892,7 +2924,9 @@ declare const mathExercises: (Exercise<{
     firstValue: number;
     reason: number;
     nbTerms: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    firstTermRank: string;
+}> | Exercise<{
     firstValue: number;
     reason: number;
     firstRank: number;
@@ -3102,6 +3136,19 @@ declare const mathExercises: (Exercise<{
     nbs: number[];
     radius: number;
     isSphere: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pointData: {
+        latLon: import("./math/geometry/point.js").PointIdentifiers;
+        "2d": import("./math/geometry/point.js").PointIdentifiers;
+    };
+    isLatitude: boolean;
+    namePointTarget: string;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pointsDict: Record<string, {
+        latLon: import("./math/geometry/point.js").PointIdentifiers;
+        "2d": import("./math/geometry/point.js").PointIdentifiers;
+    }>;
+    namePointTarget: string;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     indexFamily: number;
     indexPattern: number;
@@ -3154,6 +3201,14 @@ declare const mathExercises: (Exercise<{
     a: number;
     k: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     isSquareInside: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    angleValue: number;
+    angleIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    point: string;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    degree: number;
+    multipleOf2PiToAdd: number;
+    nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     valueIndex: number;
     isCos: boolean;
@@ -3162,23 +3217,13 @@ declare const mathExercises: (Exercise<{
     isCos: boolean;
     angleIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    randAngle: number;
-    randTrigo: number;
-    triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    randAngle: number;
-    hiddenSide: number;
-    triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    sideAsked: number;
-    givenSide: number;
-    givenAngle: number;
-    triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    angleValue: number;
-    angleIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    point: string;
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    pointIndex: number;
+}, {
+    solutionInterval: string;
+}> | Exercise<{
     trigFunction: string;
     trigValue: number;
     angleInDegrees: number;
@@ -3193,8 +3238,11 @@ declare const mathExercises: (Exercise<{
     degree: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     degree: number;
-    multipleOf2PiToAdd: number;
-    nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    leftBoundPiMultiple: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    isCos: boolean;
+    value: number;
+    associateType: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     degree: number;
     radianNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
@@ -3204,24 +3252,34 @@ declare const mathExercises: (Exercise<{
     thetaInDegree: number | undefined;
     thetaInRadNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers | undefined;
     isThetaInDegree: boolean;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    degree: number;
-    leftBoundPiMultiple: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     givenValue: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     isCosGiven: boolean;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    nameTrigoFunc: string;
+    randAngle: number;
+    randTrigo: number;
+    triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    randAngle: number;
+    hiddenSide: number;
+    triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    sideAsked: number;
+    givenSide: number;
+    givenAngle: number;
+    triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    sideType: string;
     indexPoint: number;
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
 }, {
-    acceptedInputType: string;
+    sideTypes: string[];
 }> | Exercise<{
-    sideType: string;
+    nameTrigoFunc: string;
     indexPoint: number;
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
 }, {
-    sideTypes: string[];
+    acceptedInputType: string;
 }> | Exercise<{
     questionType: "frac" | "func";
     targetType: string;