math-exercises 3.0.125 → 3.0.127

package/lib/exercises/math/functions/affines/drawAffineFromProgCalc.js

@@ -0,0 +1,223 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { isGGBLine } from "../../../../exercises/utils/geogebra/isGGBLine.js";
+import { isGGBPoint } from "../../../../exercises/utils/geogebra/isGGBPoint.js";
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { deleteObjectNamesFromAnswer } from "../../../../geogebra/deleteObjectNamesFromAnswer.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { approxEqual } from "../../../../geogebra/parsers/approxEqual.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { ProgCalcConstructor, } from "../../../../math/progCalc/progCalc.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { arrayEqual } from "../../../../utils/arrays/arrayEqual.js";
+const getInstruction = (identifiers) => {
+    const { progCalcIds, funcName } = identifiers;
+    const progCalc = ProgCalcConstructor.fromIdentifiers(progCalcIds);
+    return `La fonction $ ${funcName} $ est définie par le programme de calcul suivant :
+
+${progCalc.getArrOfFrenchStrings().map((str) => `> ${str}`).join(`
+  
+`)}
+
+Dans le repère, tracer la représentation de la fonction $ ${funcName} $.`;
+};
+const getHint = (identifiers) => {
+    const { funcName } = identifiers;
+    return `
+Exécute le programme de calcul en partant d'une valeur $x$ de ton choix.
+
+Cela te donnera la valeur de $ ${funcName}(x) $.
+
+Le point de coordonnées $ (x;${funcName}(x)) $ appartient à la droite qu'il faut tracer.
+`;
+};
+const getCorrection = (identifiers) => {
+    const { funcName, progCalcIds } = identifiers;
+    const progCalc = ProgCalcConstructor.fromIdentifiers(progCalcIds);
+    const nodeProgCalc = progCalc.toTree("x".toTree());
+    const nodeXA = (0).toTree();
+    const nodeYA = progCalc.apply(nodeXA).simplify();
+    const nodeXB = (1).toTree();
+    const nodeYB = progCalc.apply(nodeXB).simplify();
+    return `Si on exécute le programme de calcul avec $x$, on obtient: 
+
+$$
+${funcName}(x) =
+${nodeProgCalc.toTex({
+        allowMinusAnywhereInFraction: true,
+        allowDoubleMinus: true,
+        forceTimesSign: true,
+        forceParenthesis: true,
+    })} = ${nodeProgCalc
+        .simplify({
+        forbidFactorize: true,
+        towardsDistribute: true,
+        forceDistributeFractions: true,
+    })
+        .toTex()}
+$$
+
+On reconnaît l'expression d'une fonction affine.
+On va donc tracer une droite.
+
+Si on exécute le programme de calcul avec la valeur $ ${nodeXA.toTex()} $, on obtient $ ${nodeYA.toTex()} $.
+La droite passe donc par le point de coordonnées $(${nodeXA.toTex()};${nodeYA.toTex()})$.
+  
+Si on exécute le programme de calcul avec la valeur $ ${nodeXB.toTex()} $, on obtient $ ${nodeYB.toTex()} $.
+La droite passe donc par le point de coordonnées $(${nodeXB.toTex()};${nodeYB.toTex()})$.
+
+On place donc les deux points de coordonnées $(${nodeXA.toTex()};${nodeYA.toTex()})$ et $(${nodeXB.toTex()};${nodeYB.toTex()})$, 
+puis on trace la droite passant par ces deux points.
+`;
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { progCalcIds } = identifiers;
+    const progCalc = ProgCalcConstructor.fromIdentifiers(progCalcIds);
+    const xMin = 0;
+    const xMax = 1;
+    const xA = xMin;
+    const yA = progCalc.apply(xA.toTree()).evaluate();
+    const xB = xMax;
+    const yB = progCalc.apply(xB.toTree()).evaluate();
+    const studentGGB = new GeogebraConstructor({
+        isGridSimple: true,
+        customToolBar: toolBarConstructor({
+            join: true,
+        }),
+    });
+    const yMax = Math.max(yA, yB, 0);
+    const yMin = Math.min(yA, yB, 0);
+    return studentGGB.getOptions({
+        coords: studentGGB.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+        }),
+    });
+};
+const getGGBAnswer = (identifiers) => {
+    const { progCalcIds } = identifiers;
+    const progCalc = ProgCalcConstructor.fromIdentifiers(progCalcIds);
+    const xA = 0;
+    const yA = progCalc.apply(xA.toTree()).evaluate();
+    const xB = 1;
+    const yB = progCalc.apply(xB.toTree()).evaluate();
+    return [`(${xA},${yA})`, `(${xB},${yB})`, `Line[A, B]`];
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, progCalcIds }) => {
+    const studentAnswer = deleteObjectNamesFromAnswer(ans);
+    if (arrayEqual(studentAnswer, ggbAnswer))
+        return true;
+    if (studentAnswer.length !== 3)
+        return false;
+    if (!isGGBPoint(studentAnswer[0]) ||
+        !isGGBPoint(studentAnswer[1]) ||
+        !isGGBLine(studentAnswer[2]))
+        return false;
+    const A = getPoint(studentAnswer[0], "A");
+    const B = getPoint(studentAnswer[1], "B");
+    const a = (B.getYnumber() - A.getYnumber()) / (B.getXnumber() - A.getXnumber());
+    const b = A.getYnumber() - a * A.getXnumber();
+    const progCalc = ProgCalcConstructor.fromIdentifiers(progCalcIds);
+    const correctB = progCalc.apply((0).toTree()).evaluate();
+    const correctA = substract(progCalc.apply((1).toTree()), correctB).evaluate();
+    return approxEqual(a, correctA, 1) && approxEqual(b, correctB, 1);
+};
+const getPoint = (command, pointName) => {
+    const splitted = command.split(",");
+    const x = +splitted[0].replace("(", "");
+    const y = +splitted[1].replace(")", "");
+    return new Point(pointName, x.toTree(), y.toTree());
+};
+const getDrawAffineFromProgCalcQuestion = (opts) => {
+    const nbSteps = opts?.nbSteps ?? optsDefault.nbSteps;
+    const isSingleUseOperators = opts?.isSingleUseOperators ?? optsDefault.isSingleUseOperators;
+    const arrOpGenAddsub = [
+        {
+            operator: "add",
+            createParam: () => randint(-10, 11, [0]),
+        },
+        {
+            operator: "subtract",
+            createParam: () => randint(-10, 11, [0]),
+        },
+    ];
+    const arrOpGenMuldiv = [
+        {
+            operator: "opposite",
+            createParam: () => undefined,
+        },
+        {
+            operator: "multiply",
+            createParam: () => randint(-10, 11, [0, 1]),
+        },
+        {
+            operator: "divide",
+            createParam: () => randint(-10, 11, [0, 1]),
+        },
+    ];
+    const arrOpGenConfigAll = [...arrOpGenAddsub, ...arrOpGenMuldiv];
+    //ensure that there is at least 1 addsub and 1 muldiv operation
+    const opGenConfigAddsub = random(arrOpGenAddsub);
+    const opGenConfigMuldiv = random(arrOpGenMuldiv);
+    const arrOpGenConfigMandatory = [opGenConfigAddsub, opGenConfigMuldiv];
+    const progCalc = ProgCalcConstructor.randomWithMandatory(nbSteps, isSingleUseOperators, arrOpGenConfigMandatory, arrOpGenConfigAll);
+    const identifiers = {
+        progCalcIds: progCalc.toIdentifiers(),
+        funcName: random(["f", "g", "h"]),
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+const optsDefault = {
+    nbSteps: 2,
+    isSingleUseOperators: true,
+};
+const options = [
+    {
+        id: "nbSteps",
+        label: "Nombre d'étapes de transformation",
+        defaultValue: optsDefault.nbSteps,
+        values: [2, 3, 4, 5],
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+    },
+    {
+        id: "isSingleUseOperators",
+        label: "Opérateurs à usage unique",
+        defaultValue: optsDefault.isSingleUseOperators,
+        values: [true, false],
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+    },
+];
+export const drawAffineFromProgCalc = {
+    id: "drawAffineFromProgCalc",
+    label: "Tracer la représentation graphique d'une fonction affine à partir d'un programme de calcul",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getDrawAffineFromProgCalcQuestion(opts), nb),
+    options,
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/affines/index.d.ts

@@ -12,7 +12,14 @@ export * from "./affineAdjustmentComplete.js";
 export * from "./affineMeanValue.js";
 export * from "./affineExpressionFromTwoImages.js";
 export * from "./affineFromExercise.js";
+export * from "./drawAffineFromLitExp.js";
+export * from "./recognizeExprAffine.js";
 export * from "./drawAffineFrom2Points.js";
 export * from "./recognizeAffineGraph.js";
 export * from "./drawAffineFromLitExp.js";
+export * from "./coordsOfPointOnAffineFindX.js";
+export * from "./coordsOfPointOnAffineFindY.js";
+export * from "./representationOfAffine.js";
+export * from "./drawAffineFromPointAndLeadingCoeff.js";
+export * from "./drawAffineFromProgCalc.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/affines/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oCAAoC,CAAC;AACnD,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oCAAoC,CAAC;AACnD,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yCAAyC,CAAC;AACxD,cAAc,6BAA6B,CAAC"}

package/lib/exercises/math/functions/affines/index.js

@@ -12,6 +12,13 @@ export * from "./affineAdjustmentComplete.js";
 export * from "./affineMeanValue.js";
 export * from "./affineExpressionFromTwoImages.js";
 export * from "./affineFromExercise.js";
+export * from "./drawAffineFromLitExp.js";
+export * from "./recognizeExprAffine.js";
 export * from "./drawAffineFrom2Points.js";
 export * from "./recognizeAffineGraph.js";
 export * from "./drawAffineFromLitExp.js";
+export * from "./coordsOfPointOnAffineFindX.js";
+export * from "./coordsOfPointOnAffineFindY.js";
+export * from "./representationOfAffine.js";
+export * from "./drawAffineFromPointAndLeadingCoeff.js";
+export * from "./drawAffineFromProgCalc.js";

package/lib/exercises/math/functions/affines/recognizeExprAffine.d.ts

@@ -0,0 +1,20 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type ItemType = {
+    fName: string;
+    tex: string;
+    fType: string;
+    a: number | undefined;
+    b: number | undefined;
+};
+type AskedType = "affine" | "linear";
+type Identifiers = {
+    items: ItemType[];
+    askedType: AskedType;
+};
+type Options = {
+    askedType: AskedType;
+};
+export declare const recognizeExprAffine: Exercise<Identifiers, Options>;
+export declare const recognizeExprLinear: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=recognizeExprAffine.d.ts.map

package/lib/exercises/math/functions/affines/recognizeExprAffine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeExprAffine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/recognizeExprAffine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AA2BrC,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvB,CAAC;AAEF,KAAK,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAErC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,SAAS,EAAE,SAAS,CAAC;CACtB,CAAC;AAkSF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,SAAS,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoB9D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoB9D,CAAC"}

package/lib/exercises/math/functions/affines/recognizeExprAffine.js

@@ -0,0 +1,284 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { NodeShuffler } from "../../../../tree/utilities/nodeShuffler.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getStringCommaCommaAnd = (strings, stringComma = ", ", stringAnd = " et ") => {
+    return strings.slice(0, -1).length > 0
+        ? [strings.slice(0, -1).join(stringComma), ...strings.slice(-1)].join(stringAnd)
+        : strings[0];
+};
+const fNames = ["f", "g", "h", "i"];
+const getInstruction = (identifiers) => {
+    const { askedType } = identifiers;
+    return `Parmi les fonctions suivantes, laquelle ou lesquelles sont des fonctions ${(() => {
+        switch (askedType) {
+            case "affine":
+                return "affines";
+            case "linear":
+                return "linéaires";
+        }
+    })()} ?`;
+};
+const getHint = (identifiers) => {
+    const { askedType } = identifiers;
+    switch (askedType) {
+        case "affine":
+            return `L'expression d'une fonction affine est de la forme  $ax+b$,
+avec  $a$ et $b$ des nombres réels.`;
+        case "linear":
+            return `L'expression d'une fonction linéaire est de la forme  $ax$,
+avec $a$ un nombre réel.`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { items, askedType } = identifiers;
+    const affines = items.filter((item) => item.fType === askedType);
+    const affineFNames = affines.map((item) => `$${item.fName}$`);
+    const affinesTex = affines.map((item) => {
+        return `$${item.fName}(x) = ${item.tex}$`;
+    });
+    switch (askedType) {
+        case "affine": {
+            return `${getStringCommaCommaAnd(affinesTex)} ${affinesTex.length > 1 ? `sont des expressions` : `est une expression`} de la forme  $ax+b$,
+avec $a$ et $b$ des nombres réels.
+
+${affines.map((item) => {
+                return `Pour $${item.fName}(x)$, $a=${item.a}$ et $b=${item.b}$.`;
+            }).join(`
+    
+`)}
+  
+${affinesTex.length > 1
+                ? `Les fonctions affines sont`
+                : `La fonction affine est`} ${getStringCommaCommaAnd(affineFNames)}.`;
+        }
+        case "linear":
+            return `${getStringCommaCommaAnd(affinesTex)} ${affinesTex.length > 1 ? `sont des expressions` : `est une expression`} de la forme  $ax$,
+avec $a$ un nombre réel.
+
+${affines.map((item) => {
+                return `Pour $${item.fName}(x)$, $a=${item.a}$.`;
+            }).join(`
+    
+`)}
+  
+${affinesTex.length > 1
+                ? `Les fonctions linéaires sont`
+                : `La fonction linéaire est`} ${getStringCommaCommaAnd(affineFNames)}.`;
+    }
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const { items, askedType } = identifiers;
+    const propositions = [];
+    items.forEach((item, _) => {
+        const tex = `${item.fName}(x) = ${item.tex}`;
+        if (item.fType === askedType) {
+            addValidProp(propositions, tex);
+        }
+        else {
+            tryToAddWrongProp(propositions, tex);
+        }
+    });
+    return propositions;
+};
+const getRecognizeExprAffineQuestion = (opts) => {
+    const askedType = opts.askedType;
+    const nbTotal = 4;
+    const createAffineNodeObj = (affineType, fType) => {
+        switch (affineType) {
+            case "affine": {
+                const a = randint(-10, 11, [0]);
+                const b = randint(-10, 11, [0]);
+                return {
+                    node: AffineConstructor.fromCoeffs([b, a]).toTree(),
+                    a,
+                    b,
+                    fType,
+                };
+            }
+            case "linear": {
+                const a = randint(-10, 11, [0]);
+                const b = 0;
+                return {
+                    node: AffineConstructor.fromCoeffs([b, a]).toTree(),
+                    a,
+                    b,
+                    fType,
+                };
+            }
+            case "constant": {
+                const a = 0;
+                const b = randint(-10, 11, [0]);
+                return {
+                    node: b.toTree(),
+                    a,
+                    b,
+                    fType,
+                };
+            }
+        }
+    };
+    const createNonAffineFuncNode = (nonAffineType) => {
+        switch (nonAffineType) {
+            case "trinomA": {
+                const a = randint(-10, 11, [0]);
+                return TrinomConstructor.fromCoeffs([0, 0, a]).toTree();
+            }
+            case "trinomAC": {
+                const a = randint(-10, 11, [0]);
+                const c = randint(-10, 11, [0]);
+                return TrinomConstructor.fromCoeffs([c, 0, a]).toTree();
+            }
+            case "inv": {
+                const a = randint(-10, 11, [0]);
+                return frac(a, "x".toTree());
+            }
+            case "invPlusB": {
+                const a = randint(-10, 11, [0]);
+                const b = randint(-10, 11, [0]);
+                const aInvX = frac(a, "x".toTree());
+                return add(aInvX, b);
+            }
+        }
+    };
+    let affinesObj;
+    let arrayOfFillerObj;
+    switch (askedType) {
+        case "affine":
+            {
+                const nbAffineMore = probaLawFlip([
+                    [0, 0.7],
+                    [1, 0.25],
+                    [2, 0.04],
+                    [3, 0.01],
+                ]);
+                affinesObj = [
+                    createAffineNodeObj("affine", "affine"),
+                    ...[...Array(nbAffineMore).keys()].map((_) => {
+                        return createAffineNodeObj(probaLawFlip([
+                            ["affine", 0.5],
+                            ["linear", 0.45],
+                            ["constant", 0.05],
+                        ]), "affine");
+                    }),
+                ];
+                const nbFiller = nbTotal - (nbAffineMore + 1);
+                arrayOfFillerObj = [...Array(nbFiller).keys()].map((_) => {
+                    const fType = probaLawFlip([
+                        ["trinomA", 0.35],
+                        ["trinomAC", 0.35],
+                        ["inv", 0.15],
+                        ["invPlusB", 0.15],
+                    ]);
+                    return { node: createNonAffineFuncNode(fType), fType };
+                });
+            }
+            break;
+        case "linear":
+            {
+                const nbLinearMore = probaLawFlip([
+                    [0, 0.7],
+                    [1, 0.25],
+                    [2, 0.04],
+                    [3, 0.01],
+                ]);
+                affinesObj = [
+                    createAffineNodeObj("linear", "linear"),
+                    ...[...Array(nbLinearMore).keys()].map((_) => {
+                        return createAffineNodeObj("linear", "linear");
+                    }),
+                ];
+                const nbFiller = nbTotal - (nbLinearMore + 1);
+                arrayOfFillerObj = [...Array(nbFiller).keys()].map((_) => {
+                    if (coinFlip()) {
+                        const fType = probaLawFlip([
+                            ["affine", 0.55],
+                            ["constant", 0.45],
+                        ]);
+                        return {
+                            node: createAffineNodeObj(fType, fType).node,
+                            fType,
+                        };
+                    }
+                    else {
+                        const fType = probaLawFlip([
+                            ["trinomA", 0.35],
+                            ["trinomAC", 0.35],
+                            ["inv", 0.15],
+                            ["invPlusB", 0.15],
+                        ]);
+                        return {
+                            node: createNonAffineFuncNode(fType),
+                            fType,
+                        };
+                    }
+                });
+            }
+            break;
+    }
+    const shuffledArray = shuffle([...affinesObj, ...arrayOfFillerObj]);
+    const items = shuffledArray.map(({ node, fType, a, b }, i) => {
+        const tex = coinFlip()
+            ? node.toTex()
+            : NodeShuffler.deepShuffle(node).toTex();
+        return {
+            tex: tex,
+            fType,
+            fName: fNames[i],
+            a,
+            b,
+        };
+    });
+    const identifiers = { items, askedType };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const recognizeExprAffine = {
+    id: "recognizeExprAffine",
+    label: "Reconnaître l’expression d’une fonction affine",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getRecognizeExprAffineQuestion({
+        askedType: "affine",
+    }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};
+export const recognizeExprLinear = {
+    id: "recognizeExprLinear",
+    label: "Reconnaître l’expression d’une fonction linéaire",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getRecognizeExprAffineQuestion({
+        askedType: "linear",
+    }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};

package/lib/exercises/math/functions/affines/representationOfAffine.d.ts

@@ -0,0 +1,16 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type Item = {
+    tex: string;
+    isValid: boolean;
+    point?: PointIdentifiers | undefined;
+    isPointValid?: boolean;
+};
+type Identifiers = {
+    fName: string;
+    coeffs: number[];
+    items: Item[];
+};
+export declare const representationOfAffine: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=representationOfAffine.d.ts.map

package/lib/exercises/math/functions/affines/representationOfAffine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"representationOfAffine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/representationOfAffine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAWtC,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;IACrC,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAmWF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}