math-exercises 3.0.189 → 3.0.191

package/lib/exercises/math/dataRepresentations/scatterPlot/scatterPlotInterpreting.js

@@ -0,0 +1,403 @@
+import { tryToAddWrongProp, addValidProp, propWhile, shuffleProps, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { greenMain, orange, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { getCartesiansProducts } from "../../../../utils/arrays/cartesianProducts.js";
+const getComponentOfPointForStrGroupBy = (point, strGroupBy) => {
+    switch (strGroupBy) {
+        case "x":
+            return point.x;
+        case "y":
+            return point.y;
+        default:
+            throw new Error("Unsupported strGroupBy: " + strGroupBy);
+    }
+};
+const getTexCondition = (strGroupBy, nodeDataClass) => {
+    if (NodeComparator.isEqualViaSub(nodeDataClass.a, nodeDataClass.b)) {
+        return `${strGroupBy} = ${nodeDataClass.a.toTex()}`;
+    }
+    else {
+        switch (nodeDataClass.closure) {
+            case ClosureType.FF:
+                return `${nodeDataClass.a.toTex()} \\leq ${strGroupBy} \\leq ${nodeDataClass.b.toTex()}`;
+            case ClosureType.FO:
+                return `${nodeDataClass.a.toTex()} \\leq ${strGroupBy} < ${nodeDataClass.b.toTex()}`;
+            case ClosureType.OF:
+                return `${nodeDataClass.a.toTex()} < ${strGroupBy} \\leq ${nodeDataClass.b.toTex()}`;
+            case ClosureType.OO:
+                return `${nodeDataClass.a.toTex()} < ${strGroupBy} < ${nodeDataClass.b.toTex()}`;
+        }
+    }
+};
+const getInstruction = (identifiers) => {
+    const { strGroupBy, nodeIdsDataClass } = identifiers;
+    const nodeDataClass = NodeConstructor.fromIdentifiers(nodeIdsDataClass);
+    return `Si l'on considère le nuage de points ci-dessous, 
+combien y a-t-il d'éléments avec $${getTexCondition(strGroupBy, nodeDataClass)}$ ?`;
+};
+const getAnswerNode = (identifiers) => {
+    const { pointIds, strGroupBy, nodeIdsDataClass } = identifiers;
+    const arrPoint = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const nodeDataClass = NodeConstructor.fromIdentifiers(nodeIdsDataClass);
+    const count = arrPoint.filter((point) => {
+        const nodeComponent = getComponentOfPointForStrGroupBy(point, strGroupBy);
+        return nodeDataClass.includes(nodeComponent);
+    }).length;
+    return count.toTree();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { strGroupBy, nodeIdsDataClass } = identifiers;
+    const nodeDataClass = NodeConstructor.fromIdentifiers(nodeIdsDataClass);
+    return `Compte le nombre de points qui ont $${getTexCondition(strGroupBy, nodeDataClass)}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { strGroupBy, nodeIdsDataClass } = identifiers;
+    const nodeDataClass = NodeConstructor.fromIdentifiers(nodeIdsDataClass);
+    return `On compte le nombre de points qui ont $${getTexCondition(strGroupBy, nodeDataClass)}$.
+
+Il y en a $${getAnswer(identifiers)}$.
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { pointIds, strGroupBy, nodeIdsDataClass } = identifiers;
+    const arrPoint = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const nodeDataClass = NodeConstructor.fromIdentifiers(nodeIdsDataClass);
+    const [arrPointFiltered, arrPointDropped] = arrPoint.reduce((acc, point) => {
+        const nodeComponent = getComponentOfPointForStrGroupBy(point, strGroupBy);
+        if (nodeDataClass.includes(nodeComponent)) {
+            acc[0].push(point);
+        }
+        else {
+            acc[1].push(point);
+        }
+        return acc;
+    }, [[], []]);
+    const commands = [
+        ...[arrPointFiltered, arrPointDropped].flatMap((arrPoint, i) => arrPoint.flatMap((point) => point.toGGBCommand({
+            isFixed: true,
+            isSelectionnable: true,
+            showLabel: false,
+            size: 6,
+            style: 3,
+            color: i % 2 === 0 ? greenMain : "#000000",
+        }))),
+        ...(() => {
+            switch (strGroupBy) {
+                case "x":
+                    return [nodeDataClass].flatMap((nodeInterval, i) => {
+                        return [
+                            ...(() => {
+                                const value = nodeInterval.a.evaluate();
+                                return [
+                                    `l${i}l = Line((${value}, 0),(${value}, 1))`,
+                                    `SetColor(l${i}l, "${(() => {
+                                        switch (nodeInterval.closure) {
+                                            case ClosureType.FF:
+                                            case ClosureType.FO:
+                                                return orange;
+                                            case ClosureType.OF:
+                                            case ClosureType.OO:
+                                                return red;
+                                        }
+                                    })()}")`,
+                                ];
+                            })(),
+                            ...(() => {
+                                const value = nodeInterval.b.evaluate();
+                                return [
+                                    `l${i}h = Line((${value}, 0),(${value}, 1))`,
+                                    `SetColor(l${i}h, "${(() => {
+                                        switch (nodeInterval.closure) {
+                                            case ClosureType.FF:
+                                            case ClosureType.OF:
+                                                return orange;
+                                            case ClosureType.FO:
+                                            case ClosureType.OO:
+                                                return red;
+                                        }
+                                    })()}")`,
+                                ];
+                            })(),
+                        ];
+                    });
+                case "y":
+                    return [nodeDataClass].flatMap((nodeInterval, i) => {
+                        return [
+                            ...(() => {
+                                const value = nodeInterval.a.evaluate();
+                                return [
+                                    `l${i}l = Line((0, ${value}),(1,${value}))`,
+                                    `SetColor(l${i}l, "${(() => {
+                                        switch (nodeInterval.closure) {
+                                            case ClosureType.FF:
+                                            case ClosureType.FO:
+                                                return orange;
+                                            case ClosureType.OF:
+                                            case ClosureType.OO:
+                                                return red;
+                                        }
+                                    })()}")`,
+                                ];
+                            })(),
+                            ...(() => {
+                                const value = nodeInterval.b.evaluate();
+                                return [
+                                    `l${i}h = Line((0, ${value}),(1,${value}))`,
+                                    `SetColor(l${i}h, "${(() => {
+                                        switch (nodeInterval.closure) {
+                                            case ClosureType.FF:
+                                            case ClosureType.OF:
+                                                return orange;
+                                            case ClosureType.FO:
+                                            case ClosureType.OO:
+                                                return red;
+                                        }
+                                    })()}")`,
+                                ];
+                            })(),
+                        ];
+                    });
+                default:
+                    throw new Error("Unsupported strGroupBy: " + strGroupBy);
+            }
+        })(),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideGrid: true,
+        fontSize: 16,
+        xAxis: {
+            showPositive: true,
+            label: "x",
+            steps: 1,
+        },
+        yAxis: {
+            showPositive: true,
+            label: "y",
+            steps: 1,
+        },
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: -1,
+            xMax: 6,
+            yMin: -1,
+            yMax: 6,
+        }),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { pointIds } = identifiers;
+    const arrPoint = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const commands = [
+        ...arrPoint.flatMap((point) => point.toGGBCommand({
+            isFixed: true,
+            isSelectionnable: true,
+            showLabel: false,
+            size: 5,
+            style: 3,
+        })),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideGrid: false,
+        fontSize: 16,
+        xAxis: {
+            showPositive: true,
+            label: "x",
+            steps: 1,
+        },
+        yAxis: {
+            showPositive: true,
+            label: "y",
+            steps: 1,
+        },
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: -1,
+            xMax: 6,
+            yMin: -1,
+            yMax: 6,
+        }),
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { strGroupBy, nodeIdsDataClass } = identifiers;
+    const nodeDataClass = NodeConstructor.fromIdentifiers(nodeIdsDataClass);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const arrTerror = [answer];
+    //student: wrong groupBy
+    {
+        const identifiersWrong = {
+            ...identifiers,
+            strGroupBy: strGroupBy === "x" ? "y" : "x",
+        };
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+        arrTerror.push(texWrong);
+    }
+    //student: wrong closure
+    {
+        [ClosureType.FF, ClosureType.FO, ClosureType.OF].forEach((closure) => {
+            const nodeDataClassWrong = new IntervalNode(nodeDataClass.a, nodeDataClass.b, closure);
+            const identifiersWrong = {
+                ...identifiers,
+                nodeIdsDataClass: nodeDataClassWrong.toIdentifiers(),
+            };
+            const texWrong = getAnswer(identifiersWrong);
+            tryToAddWrongProp(propositions, texWrong);
+            arrTerror.push(texWrong);
+        });
+    }
+    //filler
+    {
+        propWhile(propositions, n, () => {
+            const vTerrorTarget = parseInt(random(arrTerror));
+            const vTerrorAround = vTerrorTarget + randint(-5, 5);
+            if (vTerrorAround >= 0) {
+                tryToAddWrongProp(propositions, vTerrorAround.frenchify());
+            }
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const getScatterPlotInterpretingQuestion = () => {
+    const length = 6;
+    const height = 6;
+    const arrArrDict1 = getCartesiansProducts([
+        [...Array(length).keys()].map((i) => i + 1),
+        [...Array(height).keys()].map((i) => i + 1),
+    ]).map(([x, y]) => {
+        return {
+            x,
+            y,
+            isActivated: probaFlip(0.14),
+        };
+    });
+    const arrArrDict2 = getCartesiansProducts([
+        [...Array(length - 1).keys()].map((i) => i + 1),
+        [...Array(height - 1).keys()].map((i) => i + 1),
+    ]).map(([x, y]) => {
+        return {
+            x: x + 0.333,
+            y: y + 0.333,
+            isActivated: probaFlip(0.14),
+        };
+    });
+    const arrArrDict3 = getCartesiansProducts([
+        [...Array(length - 1).keys()].map((i) => i + 1),
+        [...Array(height - 1).keys()].map((i) => i + 1),
+    ]).map(([x, y]) => {
+        return {
+            x: x + 0.666,
+            y: y + 0.666,
+            isActivated: probaFlip(0.14),
+        };
+    });
+    //at least one point should be activated
+    {
+        const dictRandom = random(arrArrDict1);
+        dictRandom.isActivated = true;
+    }
+    const arrPoint = [...arrArrDict1, ...arrArrDict2, ...arrArrDict3]
+        .filter(({ isActivated }) => isActivated)
+        .map(({ x, y }, i) => new Point(`P${i}`, x, y));
+    const strGroupBy = coinFlip() ? "x" : "y";
+    const nodeDataClass = (() => {
+        if (coinFlip()) {
+            const nodeV = randint(1, 1 + length).toTree();
+            return new IntervalNode(nodeV, nodeV, ClosureType.FF);
+        }
+        else {
+            const templateArrLengthDataClass = probaLawFlip([
+                [[1, 1, 1, 2], 0.2],
+                [[1, 2, 2], 0.4],
+                [[1, 1, 3], 0.3],
+                [[2, 3], 0.1],
+            ]);
+            const arrLengthDataClass = shuffle(templateArrLengthDataClass);
+            const arrDataClass = arrLengthDataClass.reduce((acc, lengthDataClass) => {
+                const nodeBoundLow = acc.nodeBoundLowWork;
+                const nodeBoundHigh = add(nodeBoundLow, lengthDataClass).simplify({
+                    towardsDistribute: true,
+                });
+                const closure = random([
+                    ClosureType.FF,
+                    ClosureType.FO,
+                    ClosureType.OF,
+                ]);
+                const nodeDataClass = new IntervalNode(nodeBoundLow, nodeBoundHigh, closure);
+                acc.dataClasses.push(nodeDataClass);
+                acc.nodeBoundLowWork = nodeBoundHigh;
+                return acc;
+            }, {
+                nodeBoundLowWork: (1).toTree(),
+                dataClasses: [],
+            }).dataClasses;
+            return random(arrDataClass);
+        }
+    })();
+    const identifiers = {
+        pointIds: arrPoint.map((point) => point.toIdentifiers()),
+        strGroupBy,
+        nodeIdsDataClass: nodeDataClass.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        answerFormat: "tex",
+        keys: getKeys(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const scatterPlotInterpreting = {
+    id: "scatterPlotInterpreting",
+    label: "Interpréter un nuage de points",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScatterPlotInterpretingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getAnswer,
+    isAnswerValid,
+    getPropositions,
+    getInstruction,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/derivative/derivativeEquationSolving1.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"derivativeEquationSolving1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/derivativeEquationSolving1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAYrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA6B7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,eAAe,EAAE,CAAC;CACjC,CAAC;AA6SF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAerE,CAAC"}
+{"version":3,"file":"derivativeEquationSolving1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/derivativeEquationSolving1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAarC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA6B7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,eAAe,EAAE,CAAC;CACjC,CAAC;AA4SF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAerE,CAAC"}

package/lib/exercises/math/derivation/derivative/derivativeEquationSolving1.js

@@ -1,5 +1,6 @@
 import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 import { SetVEA } from "../../../../exercises/vea/setVEA.js";
 import { createIntegratedPolynomialNode, createNodeFPolynomialFromRoots, } from "../../../../math/utils/polynomial/polynomialUtils.js";
 import { randint } from "../../../../math/utils/random/randint.js";
@@ -223,8 +224,8 @@ const createRandomIdentifiers = (typeF) => {
     return identifiers;
 };
 const getDerivativeEquationSolving1Question = (optsIn) => {
-    const arrayedOptions = optsIn ?? arrayedOptsDefault;
-    const typeF = random(arrayedOptions.typeF);
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const typeF = random(arrayedOpts.typeF);
     const identifiers = createRandomIdentifiers(typeF);
     return getQuestionFromIdentifiers(identifiers);
 };

package/lib/exercises/math/derivation/derivative/derivativeEquationSolving3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"derivativeEquationSolving3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/derivativeEquationSolving3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAarC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA6B7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,eAAe,EAAE,CAAC;IAChC,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA6TF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAerE,CAAC"}
+{"version":3,"file":"derivativeEquationSolving3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/derivativeEquationSolving3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAcrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA6B7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,eAAe,EAAE,CAAC;IAChC,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA4TF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAerE,CAAC"}

package/lib/exercises/math/derivation/derivative/derivativeEquationSolving3.js

@@ -1,5 +1,6 @@
 import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 import { SetVEA } from "../../../../exercises/vea/setVEA.js";
 import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
 import { createIntegratedPolynomialNode, createNodeFPolynomialFromRoots, } from "../../../../math/utils/polynomial/polynomialUtils.js";
@@ -236,8 +237,8 @@ const createRandomIdentifiers = (typeF) => {
     return identifiers;
 };
 const getDerivativeEquationSolving3Question = (optsIn) => {
-    const arrayedOptions = optsIn ?? arrayedOptsDefault;
-    const typeF = random(arrayedOptions.typeF);
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const typeF = random(arrayedOpts.typeF);
     const identifiers = createRandomIdentifiers(typeF);
     return getQuestionFromIdentifiers(identifiers);
 };

package/lib/exercises/math/derivation/derivative/valueDerivativeFromFunctionExpression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"valueDerivativeFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/valueDerivativeFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgF7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,CAAC;IAC/B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAqQF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgDF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAoBR,CAAC"}
+{"version":3,"file":"valueDerivativeFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/valueDerivativeFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgF7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,CAAC;IAC/B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoQF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgDF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/derivation/derivative/valueDerivativeFromFunctionExpression.js

@@ -1,5 +1,6 @@
 import { addValidProp, tryToAddWrongProp, propWhile, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 import { AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { PolynomialConstructor } from "../../../../math/polynomials/polynomial.js";
 import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
@@ -260,8 +261,8 @@ const createQCPassedIdentifiers = (typeF) => {
     return identifiers;
 };
 const getValueDerivativeFromFunctionExpressionQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? arrayedOptsDefault;
-    const typeF = random(arrayedOptions.typeF);
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const typeF = random(arrayedOpts.typeF);
     const identifiers = createQCPassedIdentifiers(typeF);
     return getQuestionFromIdentifiers(identifiers);
 };

package/lib/exercises/math/derivation/problems/problemMaximizeProfitFindProduction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"problemMaximizeProfitFindProduction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/problems/problemMaximizeProfitFindProduction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAIL,0BAA0B,EAC3B,MAAM,6DAA6D,CAAC;AAYrE,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,MAAM,EAAE,0BAA0B,EAAE,CAAC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAqaF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAsBF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CACxD,WAAW,EACX,OAAO,CAoBR,CAAC"}
+{"version":3,"file":"problemMaximizeProfitFindProduction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/problems/problemMaximizeProfitFindProduction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAIL,0BAA0B,EAC3B,MAAM,6DAA6D,CAAC;AAYrE,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,MAAM,EAAE,0BAA0B,EAAE,CAAC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoaF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAsBF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CACxD,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/derivation/problems/problemMaximizeProfitFindProduction.js

@@ -1,5 +1,6 @@
 import { addValidProp, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
 import { blueMain, orange, red } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
@@ -294,8 +295,8 @@ const isIdentifiersQCPassed = (identifiers) => {
     return !isExploding(identifiers);
 };
 const getProblemMaximizeProfitFindProductionQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? arrayedOptsDefault;
-    const typeF = random(arrayedOptions.typeF);
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const typeF = random(arrayedOpts.typeF);
     let identifiers;
     let counter = -1;
     let isValid = false;

package/lib/exercises/math/derivation/problems/problemMovementOnLineFindSpeedAtPoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"problemMovementOnLineFindSpeedAtPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/problems/problemMovementOnLineFindSpeedAtPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA0E7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,oBAAoB,EAAE,eAAe,CAAC;IACtC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0RF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAqBR,CAAC"}
+{"version":3,"file":"problemMovementOnLineFindSpeedAtPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/problems/problemMovementOnLineFindSpeedAtPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA0E7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,oBAAoB,EAAE,eAAe,CAAC;IACtC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAyRF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAqBR,CAAC"}

package/lib/exercises/math/derivation/problems/problemMovementOnLineFindSpeedAtPoint.js

@@ -1,5 +1,6 @@
 import { addValidProp, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 import { AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
 import { getArrNodeCoeffOfPolynomialNode } from "../../../../math/utils/polynomial/polynomialUtils.js";
@@ -247,8 +248,8 @@ const isIdentifiersQCPassed = (identifiers) => {
     return !isExploding(identifiers);
 };
 const getProblemMovementOnLineFindSpeedAtPointQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? arrayedOptsDefault;
-    const typeF = random(arrayedOptions.typeF);
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const typeF = random(arrayedOpts.typeF);
     let identifiers;
     let counter = -1;
     let isValid = false;

package/lib/exercises/math/derivation/tangent/tangentEquationFromFunctionExpression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tangentEquationFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/tangentEquationFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgF7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,CAAC;IAC/B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAqXF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgDF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAqBR,CAAC"}
+{"version":3,"file":"tangentEquationFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/tangentEquationFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgF7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,CAAC;IAC/B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoXF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgDF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAqBR,CAAC"}

package/lib/exercises/math/derivation/tangent/tangentEquationFromFunctionExpression.js

@@ -1,5 +1,6 @@
 import { addValidProp, tryToAddWrongProp, propWhile, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 import { polynomialVEA } from "../../../../exercises/vea/polynomialVEA.js";
 import { AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { PolynomialConstructor } from "../../../../math/polynomials/polynomial.js";
@@ -253,7 +254,7 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     ]);
 };
 const getKeys = () => {
-    return [];
+    return ["x", "y", "equal"];
 };
 const isAnswerValid = (ans, { answer }) => {
     try {
@@ -305,8 +306,8 @@ const isIdentifiersQCPassed = (identifiers) => {
     return !isExploding(identifiers) && isVEAOk(identifiers);
 };
 const getTangentEquationFromFunctionExpressionQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? arrayedOptsDefault;
-    const typeF = random(arrayedOptions.typeF);
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const typeF = random(arrayedOpts.typeF);
     let identifiers;
     let isValid = false;
     let counter = -1;

package/lib/exercises/math/derivation/variations/findAbscissaOfExtremaFromFunctionExpression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findAbscissaOfExtremaFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/findAbscissaOfExtremaFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA4R7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA2LF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoCF,eAAO,MAAM,2CAA2C,EAAE,QAAQ,CAChE,WAAW,EACX,OAAO,CAqBR,CAAC"}
+{"version":3,"file":"findAbscissaOfExtremaFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/findAbscissaOfExtremaFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA6R7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA0LF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoCF,eAAO,MAAM,2CAA2C,EAAE,QAAQ,CAChE,WAAW,EACX,OAAO,CAqBR,CAAC"}

package/lib/exercises/math/derivation/variations/findAbscissaOfExtremaFromFunctionExpression.js

@@ -13,6 +13,7 @@ import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js
 import { SetVEA } from "../../../../exercises/vea/setVEA.js";
 import { dividersOf } from "../../../../math/utils/arithmetic/dividersOf.js";
 import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 const tryToSimplify = (node, simplifyOptions) => {
     try {
         return node.simplify(simplifyOptions);
@@ -353,9 +354,9 @@ const createRandomIdentifiers = (typeF, typeRoots) => {
     return identifiers;
 };
 const getFindAbscissaOfExtremaFromFunctionExpressionQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? arrayedOptsDefault;
-    const typeF = random(arrayedOptions.typeF);
-    const typeRoots = random(arrayedOptions.typeRoots);
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const typeF = random(arrayedOpts.typeF);
+    const typeRoots = random(arrayedOpts.typeRoots);
     const identifiers = createRandomIdentifiers(typeF, typeRoots);
     return getQuestionFromIdentifiers(identifiers);
 };

package/lib/exercises/math/derivation/variations/findExtremaFromFunctionExpression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findExtremaFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/findExtremaFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkS7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAiSF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoCF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqB1E,CAAC"}
+{"version":3,"file":"findExtremaFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/findExtremaFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAmS7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAiSF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAqCF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqB1E,CAAC"}

package/lib/exercises/math/derivation/variations/findExtremaFromFunctionExpression.js

@@ -19,6 +19,7 @@ import { NodeUtils } from "../../../../tree/utilities/nodeUtils.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 const tryToSimplify = (node, simplifyOptions) => {
     try {
         return node.simplify(simplifyOptions);
@@ -415,9 +416,9 @@ const isIdentifiersQCPassed = (identifiers) => {
     return isSolutionPrettyAndNotExploding(identifiers) && isVEAOk(identifiers);
 };
 const getFindExtremaFromFunctionExpressionQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? arrayedOptsDefault;
-    const typeF = random(arrayedOptions.typeF);
-    const typeRoots = random(arrayedOptions.typeRoots);
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const typeF = random(arrayedOpts.typeF);
+    const typeRoots = random(arrayedOpts.typeRoots);
     let identifiers;
     let isValid = false;
     let counter = -1;

package/lib/exercises/math/derivation/variations/plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAQtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA6J7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,eAAe,EAAE,eAAe,EAAE,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAubF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,iEAAiE,EAAE,QAAQ,CACtF,WAAW,EACX,OAAO,CAuBR,CAAC"}
+{"version":3,"file":"plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAQtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA6J7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,eAAe,EAAE,eAAe,EAAE,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAqbF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,iEAAiE,EAAE,QAAQ,CACtF,WAAW,EACX,OAAO,CAuBR,CAAC"}

package/lib/exercises/math/derivation/variations/plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.js

@@ -1,5 +1,6 @@
 import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 import { blueMain, greenMain } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
@@ -313,8 +314,8 @@ const isGGBAnswerValid = (ggbAns, { ggbAnswer: _ggbAnswer, ...identifiers }) =>
     }
 };
 const getPlausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomialQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? arrayedOptsDefault;
-    const typeF = random(arrayedOptions.typeF);
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const typeF = random(arrayedOpts.typeF);
     const [arrX, nodeF] = (() => {
         let arrX;
         let nodeF;