math-exercises 3.0.124 → 3.0.126

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

@@ -0,0 +1 @@
+{"version":3,"file":"coordsOfPointOnAffineFindY.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/coordsOfPointOnAffineFindY.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA6GF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}

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

@@ -0,0 +1,100 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+const getInstruction = (identifiers) => {
+    const { xValue, coeffs } = identifiers;
+    const affine = AffineConstructor.fromCoeffs(coeffs);
+    return `Le point $M$ d'abscisse $${xValue}$ appartient à la courbe d'équation 
+
+$$
+y=${affine.toTex()} 
+$$
+
+Quelles sont les coordonnées de $M$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { xValue, coeffs } = identifiers;
+    const polynome = AffineConstructor.fromCoeffs(coeffs);
+    const yValue = polynome.calculate(xValue);
+    const answer = `(${xValue.frenchify()};${yValue.frenchify()})`;
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { xValue, coeffs } = identifiers;
+    const affine = new Affine(coeffs[1], coeffs[0], "x_{M}");
+    return `Les coordonnées de $M$ vérifient:
+
+$$
+${affine.toTex()} = y_{M} 
+$$
+
+On doit calculer : 
+  
+$$
+y_{M} = ${coeffs[1].frenchify()} \\times ${xValue.frenchify()} + ${coeffs[0].frenchify()}  
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { xValue, coeffs } = identifiers;
+    const polynome = AffineConstructor.fromCoeffs(coeffs);
+    const yValue = polynome.calculate(xValue);
+    const answer = getAnswer(identifiers);
+    return `On calcule : 
+  
+$$
+y_{M} = ${coeffs[1].frenchify()} \\times ${xValue
+        .toTree()
+        .toTex({ explicitNumberWriting: true })} + ${coeffs[0].frenchify()}  
+$$
+
+$$
+y_{M} = ${yValue.frenchify()}  
+$$
+
+Les coordonnées de $M$ sont donc $${answer}$.`;
+};
+const getPropositions = (n, { answer, coeffs, xValue }) => {
+    const [p, m] = coeffs;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const poly = AffineConstructor.fromCoeffs(coeffs);
+    tryToAddWrongProp(propositions, `(${m.frenchify()}, ${p.frenchify()})`);
+    tryToAddWrongProp(propositions, `(${p.frenchify()}, ${m.frenchify()})`);
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()}, ${multiply(m, xValue).simplify().toTex()})`);
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()}, ${poly.calculate(1).frenchify()})`);
+    return shuffleProps(propositions, n);
+};
+const getCoordsOfPointOnAffineFindYQuestion = () => {
+    const polynome1 = new Polynomial([randint(-9, 10), randint(-5, 6, [0])]);
+    const xValue = randint(-9, 10);
+    const identifiers = { coeffs: polynome1.coefficients, xValue };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const coordsOfPointOnAffineFindY = {
+    id: "coordsOfPointOnAffineFindY",
+    getPropositions,
+    label: "Déterminer les coordonnées d'un point appartenant à une courbe et dont on connaît l'abscisse",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getCoordsOfPointOnAffineFindYQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -1,13 +1,13 @@
-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 { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { random } from "../../../../utils/alea/random.js";
+import { isGGBLine } from "../../../../exercises/utils/geogebra/isGGBLine.js";
+import { isGGBPoint } from "../../../../exercises/utils/geogebra/isGGBPoint.js";
+import { deleteObjectNamesFromAnswer } from "../../../../geogebra/deleteObjectNamesFromAnswer.js";
+import { approxEqual } from "../../../../geogebra/parsers/approxEqual.js";
+import { Point } from "../../../../math/geometry/point.js";
 import { arrayEqual } from "../../../../utils/arrays/arrayEqual.js";
 const getInstruction = (identifiers) => {
     const { correctA, correctB, nameFunc } = identifiers;

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

@@ -0,0 +1,16 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    pointIdsA: PointIdentifiers;
+    leadingCoeff: NodeIdentifiers;
+    numberType: string;
+    pointIdsB: PointIdentifiers;
+    funcName: string;
+};
+type Options = {
+    numberTypes: string[];
+};
+export declare const drawAffineFromPointAndLeadingCoeff: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=drawAffineFromPointAndLeadingCoeff.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drawAffineFromPointAndLeadingCoeff.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/drawAffineFromPointAndLeadingCoeff.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAOtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAI7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,YAAY,EAAE,eAAe,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAmJF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA4FF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CACvD,WAAW,EACX,OAAO,CAqBR,CAAC"}

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

@@ -0,0 +1,215 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { isGGBLine } from "../../../../exercises/utils/geogebra/isGGBLine.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { random } from "../../../../utils/alea/random.js";
+import { Line } from "../../../../math/geometry/line.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+const getHint = () => {
+    return `Si $f$ est une fonction telle que $f(x) = y$, 
+alors la droite représentative de f passe par le point de coordonnées $(x;y)$.
+Si le coefficient directeur vaut $\\frac{v}{h}$ alors le point de coordonnées $(x+h;y+v)$
+appartient aussi à la droite représentative de $f$.`;
+};
+const getCorrection = (identifiers) => {
+    const { pointIdsA, leadingCoeff, numberType, pointIdsB, funcName } = identifiers;
+    const pointA = PointConstructor.fromIdentifiers(pointIdsA);
+    const pointB = PointConstructor.fromIdentifiers(pointIdsB);
+    const coeff = NodeConstructor.fromIdentifiers(leadingCoeff);
+    const texCoeff = numberType === "Fraction" ? coeff.toTex() : coeff.evaluate().frenchify();
+    const offsetVert = coeff.leftChild.evaluate();
+    const isUp = Math.sign(offsetVert) >= 0;
+    const offsetHoriz = coeff.rightChild.evaluate();
+    return `La fonction $${funcName}$ est une fonction affine.
+Sa représentation graphique est une droite, que l'on va nommer $d$.
+
+On sait que $ ${funcName}(${pointA.x.toTex()}) = ${pointA.y.toTex()} $.
+C'est-à-dire que le point $A$ de coordonnées $(${pointA.x.toTex()}; ${pointA.y.toTex()})$ appartient à $d$.
+
+Comme le coefficient directeur est égal à $${texCoeff} = ${coeff.toTex({
+        allowMinusAnywhereInFraction: true,
+        explicitNumberWriting: true,
+    })}$ 
+alors à partir de $A$, on se déplace verticalement de $${Math.abs(offsetVert).frenchify()}$ carreaux vers le ${isUp ? `haut` : `bas`} 
+quand on se déplace horizontalement de $${offsetHoriz.frenchify()}$ carreaux vers la droite.
+
+C'est-à-dire que le point $B$ de coordonnées $(${pointB.x.toTex()}; ${pointB.y.toTex()})$ appartient à $d$.
+
+On trace donc la droite passant $A(${pointA.x.toTex()}; ${pointA.y.toTex()})$ et $B(${pointB.x
+        .evaluate()
+        .frenchify()}; ${pointB.y.evaluate().frenchify()})$.`;
+};
+const getInstruction = (identifiers) => {
+    const { pointIdsA, leadingCoeff, numberType, funcName } = identifiers;
+    const pointA = PointConstructor.fromIdentifiers(pointIdsA);
+    const coeff = NodeConstructor.fromIdentifiers(leadingCoeff);
+    const texCoeff = numberType === "Fraction" ? coeff.toTex() : coeff.evaluate().frenchify();
+    return `La fonction $${funcName}$ est telle que $f(x)=${texCoeff}x+b$ avec b un nombre réel et 
+$ ${funcName}(${pointA.x.toTex()}) = ${pointA.y.toTex()} $.
+
+Dans le repère, tracer la représentation graphique de la fonction $${funcName}$.`;
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { pointIdsA, pointIdsB } = identifiers;
+    const pointA = PointConstructor.fromIdentifiers(pointIdsA);
+    const pointB = PointConstructor.fromIdentifiers(pointIdsB);
+    const studentGGB = new GeogebraConstructor({
+        isGridSimple: true,
+        customToolBar: toolBarConstructor({
+            join: true,
+        }),
+    });
+    const [xA, xB, yA, yB] = [pointA.x, pointB.x, pointA.y, pointB.y].map((node) => node.evaluate());
+    const [xMin, xMax, yMin, yMax] = [
+        Math.min(xA, xB),
+        Math.max(xA, xB),
+        Math.min(yA, yB),
+        Math.max(yA, yB),
+    ];
+    return studentGGB.getOptions({
+        coords: studentGGB.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMax,
+            yMin,
+            forceShowAxes: true,
+        }),
+    });
+};
+const getGGBAnswer = (identifiers) => {
+    const { pointIdsA, pointIdsB } = identifiers;
+    const pointA = PointConstructor.fromIdentifiers(pointIdsA);
+    const pointB = PointConstructor.fromIdentifiers(pointIdsB);
+    return [
+        `(${pointA.x.evaluate()},${pointA.y.evaluate()})`,
+        `(${pointB.x.evaluate()},${pointB.y.evaluate()})`,
+        `Line[A, B]`,
+    ];
+};
+const isGGBAnswerValid = (ans, { pointIdsA, pointIdsB }) => {
+    try {
+        //parse la line (si +1, faux)
+        // parse le spoints de la line
+        //transformer en vrai droite
+        // checker si A et B sont sur la droite
+        const lines = ans.filter((s) => isGGBLine(s));
+        if (lines.length !== 1)
+            return false;
+        const pointNames = lines[0]
+            .split("Line")[1]
+            .replace("[", "")
+            .replace("]", "")
+            .replace(" ", "")
+            .split(",");
+        const pointCmds = ans.filter((s) => s.startsWith(pointNames[0] + "=") || s.startsWith(pointNames[1] + "="));
+        const pointsCoords = pointCmds.map((cmd) => cmd
+            .split("=")[1]
+            .replace("(", "")
+            .replace(")", "")
+            .split(",")
+            .map((n) => Number(n)));
+        const points = pointsCoords.map((coord) => new Point("A", coord[0], coord[1]));
+        const line = new Line(points[0], points[1]);
+        const A = PointConstructor.fromIdentifiers(pointIdsA);
+        const B = PointConstructor.fromIdentifiers(pointIdsB);
+        return line.includes(A, 0.5) && line.includes(B, 0.5);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const optsDefault = {
+    numberTypes: ["Entier", ".5", "Fraction"],
+};
+const options = [
+    {
+        id: "numberTypes",
+        label: "Type de coefficient directeur",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["Entier", ".5", "Fraction"],
+        defaultValue: optsDefault.numberTypes,
+    },
+];
+const getDrawAffineFromPointAndLeadingCoeffQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const numberType = random(opts.numberTypes);
+    let v;
+    let h;
+    switch (numberType) {
+        case ".5":
+            {
+                h = 2;
+                v = random([...Array(21).keys()].map((i) => i - 10).filter((v) => v % h !== 0));
+            }
+            break;
+        case "Fraction":
+            {
+                v = randint(-11, 11, [-11, 0]);
+                h = random([2, 3, 4, 5, 6, 7, 8, 9].filter((h) => v % h !== 0));
+            }
+            break;
+        default:
+        case "Entier":
+            {
+                v = randint(-11, 11, [-11]);
+                h = 1;
+            }
+            break;
+    }
+    const leadingCoeffNode = frac(v, h);
+    const availableCoordValues = [...Array(21).keys()].map((i) => i - 10);
+    const [xA, yA] = [0, 1].map((_) => random(availableCoordValues));
+    const xOffset = leadingCoeffNode.rightChild.evaluate();
+    const [xB, yB] = [
+        add(xA, xOffset),
+        add(yA, leadingCoeffNode.leftChild.evaluate()),
+    ];
+    const pointA = new Point("A", xA, yA);
+    const pointB = new Point("B", xB, yB);
+    const funcName = random(["f", "g"]);
+    const identifiers = {
+        pointIdsA: pointA.toIdentifiers(),
+        leadingCoeff: leadingCoeffNode.toIdentifiers(),
+        numberType: numberType,
+        pointIdsB: pointB.toIdentifiers(),
+        funcName,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+export const drawAffineFromPointAndLeadingCoeff = {
+    id: "drawAffineFromPointAndLeadingCoeff",
+    label: "Tracer la représentation graphique d'une fonction affine avec un point et le coefficient directeur",
+    isSingleStep: true,
+    answerType: "GGB",
+    generator: (nb, opts) => getDistinctQuestions(() => getDrawAffineFromPointAndLeadingCoeffQuestion(opts), nb),
+    options,
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getGGBAnswer,
+    getInstruction,
+    getStudentGGBOptions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { ProgCalcIdentifiers } from "../../../../math/progCalc/progCalc.js";
+type Identifiers = {
+    progCalcIds: ProgCalcIdentifiers;
+    funcName: string;
+};
+type Options = {
+    nbSteps: Exclude<number, 0>;
+    isSingleUseOperators: boolean;
+};
+export declare const drawAffineFromProgCalc: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=drawAffineFromProgCalc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drawAffineFromProgCalc.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/drawAffineFromProgCalc.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,mBAAmB,EAEpB,MAAM,iCAAiC,CAAC;AAMzC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,mBAAmB,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAgNF,KAAK,OAAO,GAAG;IACb,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAC5B,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CAAC;AAwBF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBjE,CAAC"}

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

@@ -0,0 +1,206 @@
+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}
+`)}
+
+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 { progCalcIds, funcName } = 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 `
+Toutes les fonctions dans le programme de calcul sont des fonctions affines,
+la fonction $ ${funcName} $ est donc une fonction affine. On va donc tracer une droite.
+
+Si on exécute le programme de calcul avec la valeur $ ${xA} $, on obtient $ ${yA} $.
+La droite passe donc par le point de coordonnées $(${xA};${yA})$.
+  
+Si on exécute le programme de calcul avec la valeur $ ${xB} $, on obtient $ ${yB} $.
+La droite passe donc par le point de coordonnées $(${xB};${yB})$.
+
+On place donc les deux points de coordonnées $(${xA};${yA})$ et $(${xB};${yB})$, 
+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"}