math-exercises 3.0.146 → 3.0.147

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

@@ -1,8 +1,13 @@
 import { Exercise } from "../../../../exercises/exercise.js";
+type Options = {
+    isLinear: boolean;
+};
 type Identifiers = {
+    isLinear: boolean;
     b: number;
     secondPoint: number[];
 };
-export declare const affineExpressionReading: Exercise<Identifiers>;
+export declare const affineExpressionReading: Exercise<Identifiers, Options>;
+export declare const linearExpressionReading: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=affineExpressionReading.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"affineExpressionReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineExpressionReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA8KF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}
+{"version":3,"file":"affineExpressionReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineExpressionReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAiTF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBlE,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBlE,CAAC"}

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

@@ -6,6 +6,7 @@ import { Rational } from "../../../../math/numbers/rationals/rational.js";
 import { AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
@@ -14,8 +15,16 @@ import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
-const getInstruction = () => {
-    return `Ci-dessous est tracée la courbe représentative d'une fonction affine $f$. Déterminer graphiquement l'expression algébrique de $f(x)$.`;
+const rebuildIdentifiers = (oldIds) => {
+    const newIds = Object.assign({}, oldIds, {
+        isLinear: false,
+    });
+    return newIds;
+};
+const getInstruction = (_, opts) => {
+    return `Ci-dessous est tracée la courbe représentative d'une fonction ${opts?.isLinear ? "linéaire" : "affine"} $f$. 
+Déterminer graphiquement l'expression algébrique de $f(x)$.
+(Écrire la réponse sous la forme "$f(x)=$...")`;
 };
 const getGGBOptions = (identifiers) => {
     const { b, secondPoint } = identifiers;
@@ -35,8 +44,25 @@ const getGGBOptions = (identifiers) => {
         coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
     });
 };
-const getHint = () => {
-    return `L'expression algébrique d'une fonction affine est de la forme :
+const getHint = (_, opts) => {
+    if (opts?.isLinear) {
+        return `L'expression algébrique d'une fonction linéaire est de la forme :
+  
+$$
+f(x) = ax
+$$
+
+$a$ est le coefficient directeur. Pour le lire, repère un point $A(x_A;y_A)$ de la droite, qui n'est pas l'origine.
+
+Alors :
+
+$$
+a = \\frac{y_A}{x_A}
+$$
+`;
+    }
+    else {
+        return `L'expression algébrique d'une fonction affine est de la forme :
   
 $$
 f(x) = ax+b
@@ -49,10 +75,33 @@ $a$ est le coefficient directeur. Pour le déterminer, on repère deux points $A
 $$
 a = \\frac{y_B-y_A}{x_B-x_A}
 $$`;
+    }
 };
-const getCorrection = (identifiers) => {
+const getCorrection = (identifiers, opts) => {
     const { b, secondPoint } = identifiers;
-    return `On lit graphiquement que l'ordonnée à l'origine est $${b}$ : c'est l'ordonnée du point d'abscisse $0$ appartenant à la droite.
+    if (opts?.isLinear) {
+        return `La droite passe par l'origine. La fonction est donc une fonction linéaire. $f$ est donc de la forme :
+
+$$
+f(x) = ax
+$$
+
+Pour trouver $a$, on repère que le point de coordonnées $(${secondPoint[0].frenchify()};${secondPoint[1].frenchify()})$ appartient à la droite.
+
+On a donc : 
+
+$$
+a = ${frac(secondPoint[1], secondPoint[0]).toSimplificationTex()}
+$$
+
+L'expression algébrique de la fonction $f$ est donc :
+
+$$
+${getAnswer(identifiers)}
+$$`;
+    }
+    else {
+        return `On lit graphiquement que l'ordonnée à l'origine est $${b}$ : c'est l'ordonnée du point d'abscisse $0$ appartenant à la droite.
   
 Pour trouver $a$, on repère que la droite passe par le point de coordonnées $(${secondPoint[0]};${secondPoint[1]})$. On a alors : 
 
@@ -65,6 +114,7 @@ L'expression algébrique de la fonction $f$ est donc :
 $$
 ${getAnswer(identifiers)}
 $$`;
+    }
 };
 const getAnswer = (identifiers) => {
     const { b, secondPoint } = identifiers;
@@ -74,51 +124,68 @@ const getAnswer = (identifiers) => {
     const answer = new EqualNode(new VariableNode("f(x)"), new AddNode(new MultiplyNode(leadingCoeff, new VariableNode("x")), new NumberNode(b)).simplify({ forceDistributeFractions: true, forbidFactorize: true })).toTex();
     return answer;
 };
-const getAffineExpressionReadingQuestion = () => {
-    const b = randint(-5, 6);
-    const secondPoint = [randint(-5, 6, [0]), randint(-5, 6)];
-    const identifiers = { b, secondPoint };
-    //[0,b] et [x,y]
-    //a = (y-b)/x
-    return getQuestionFromIdentifiers(identifiers);
-};
-const getQuestionFromIdentifiers = (identifiers) => {
-    const question = {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
-        keys: ["fx", "equal", "x"],
-        ggbOptions: getGGBOptions(identifiers),
-        answerFormat: "tex",
-        identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
-    };
-    return question;
-};
-const getPropositions = (n, { answer, b, secondPoint }) => {
-    const propositions = [];
-    addValidProp(propositions, answer);
-    const wrongAs = [];
-    if (secondPoint[1] - b !== 0)
-        wrongAs.push(new Rational(secondPoint[0], secondPoint[1] - b).simplify().toTree());
-    if (secondPoint[0] !== 0)
-        wrongAs.push(new Rational(secondPoint[1] + b, secondPoint[0]).simplify().toTree());
-    if (secondPoint[1] + b !== 0)
-        wrongAs.push(new Rational(secondPoint[0], secondPoint[1] + b).simplify().toTree());
-    if (b !== 0)
-        wrongAs.push(new Rational(secondPoint[1] - secondPoint[0], b).simplify().toTree());
-    const fx = new VariableNode("f(x)");
-    const x = new VariableNode("x");
-    wrongAs.forEach((coeff) => {
-        tryToAddWrongProp(propositions, new EqualNode(fx, new AddNode(new MultiplyNode(coeff, x), new NumberNode(b)).simplify({
-            forceDistributeFractions: true,
-            forbidFactorize: true,
-        })).toTex());
-    });
-    propWhile(propositions, n, () => {
-        tryToAddWrongProp(propositions, new EqualNode(fx, AffineConstructor.random().toTree()).toTex());
-    });
-    return shuffleProps(propositions, n);
+const getPropositions = (n, { answer, b, secondPoint, isLinear }) => {
+    // if (opts?.isLinear) {
+    if (isLinear) {
+        const a = new Rational(secondPoint[1] - b, secondPoint[0])
+            .simplify()
+            .toTree();
+        const propositions = [];
+        addValidProp(propositions, answer);
+        const wrongSecondPoints = [-1, 0, 1].flatMap((offsetX) => [-1, 0, 1]
+            .filter((offsetY) => offsetX !== 0 && offsetY !== 0 && secondPoint[0] + offsetX !== 0)
+            .map((offsetY) => {
+            return [secondPoint[0] + offsetX, secondPoint[1] + offsetY];
+        }));
+        const wrongAs = [
+            frac(1, a).simplify(),
+            opposite(a),
+            frac(1, opposite(a)),
+            ...wrongSecondPoints.map((secondPoint) => {
+                const leadingCoeff = new Rational(secondPoint[1], secondPoint[0])
+                    .simplify()
+                    .toTree();
+                return leadingCoeff;
+            }),
+        ];
+        const fx = new VariableNode("f(x)");
+        const x = new VariableNode("x");
+        wrongAs.forEach((coeff) => {
+            tryToAddWrongProp(propositions, new EqualNode(fx, new MultiplyNode(coeff, x).simplify({
+                forceDistributeFractions: true,
+                forbidFactorize: true,
+            })).toTex());
+        });
+        propWhile(propositions, n, () => {
+            tryToAddWrongProp(propositions, new EqualNode(fx, AffineConstructor.random().toTree()).toTex());
+        });
+        return shuffleProps(propositions, n);
+    }
+    else {
+        const propositions = [];
+        addValidProp(propositions, answer);
+        const wrongAs = [];
+        if (secondPoint[1] - b !== 0)
+            wrongAs.push(new Rational(secondPoint[0], secondPoint[1] - b).simplify().toTree());
+        if (secondPoint[0] !== 0)
+            wrongAs.push(new Rational(secondPoint[1] + b, secondPoint[0]).simplify().toTree());
+        if (secondPoint[1] + b !== 0)
+            wrongAs.push(new Rational(secondPoint[0], secondPoint[1] + b).simplify().toTree());
+        if (b !== 0)
+            wrongAs.push(new Rational(secondPoint[1] - secondPoint[0], b).simplify().toTree());
+        const fx = new VariableNode("f(x)");
+        const x = new VariableNode("x");
+        wrongAs.forEach((coeff) => {
+            tryToAddWrongProp(propositions, new EqualNode(fx, new AddNode(new MultiplyNode(coeff, x), new NumberNode(b)).simplify({
+                forceDistributeFractions: true,
+                forbidFactorize: true,
+            })).toTex());
+        });
+        propWhile(propositions, n, () => {
+            tryToAddWrongProp(propositions, new EqualNode(fx, AffineConstructor.random().toTree()).toTex());
+        });
+        return shuffleProps(propositions, n);
+    }
 };
 const isAnswerValid = (ans, { answer }) => {
     try {
@@ -140,12 +207,58 @@ const isAnswerValid = (ans, { answer }) => {
         return handleVEAError(err);
     }
 };
+const getAffineExpressionReadingQuestion = (opts) => {
+    const isLinear = opts?.isLinear ?? false;
+    let b;
+    let secondPoint;
+    if (opts?.isLinear) {
+        b = 0;
+        secondPoint = [randint(-5, 6, [0]), randint(-5, 6, [0])];
+    }
+    else {
+        b = randint(-5, 6);
+        secondPoint = [randint(-5, 6, [0]), randint(-5, 6)];
+    }
+    const identifiers = { b, secondPoint, isLinear };
+    //[0,b] et [x,y]
+    //a = (y-b)/x
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: ["fx", "equal", "x"],
+        ggbOptions: getGGBOptions(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
 export const affineExpressionReading = {
     id: "affineExpressionReading",
     connector: "=",
     label: "Lire graphiquement l'expression d'une fonction affine",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getAffineExpressionReadingQuestion, nb),
+    generator: (nb) => getDistinctQuestions(() => getAffineExpressionReadingQuestion({ isLinear: false }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};
+export const linearExpressionReading = {
+    id: "linearExpressionReading",
+    connector: "=",
+    label: "Lire graphiquement l'expression d'une fonction linéaire",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getAffineExpressionReadingQuestion({ isLinear: true }), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
@@ -154,4 +267,5 @@ export const affineExpressionReading = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    rebuildIdentifiers: rebuildIdentifiers,
 };

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

@@ -1,9 +1,13 @@
 import { Exercise } from "../../../../exercises/exercise.js";
+type Options = {
+    isLinear: boolean;
+};
 type Identifiers = {
     correctA: number;
     correctB: number;
     nameFunc: string;
 };
-export declare const drawAffineFromLitExp: Exercise<Identifiers>;
+export declare const drawAffineFromLitExp: Exercise<Identifiers, Options>;
+export declare const drawLinearFromLitExp: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=drawAffineFromLitExp.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"drawAffineFromLitExp.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/drawAffineFromLitExp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAwHF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}
+{"version":3,"file":"drawAffineFromLitExp.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/drawAffineFromLitExp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAarC,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAkJF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqB/D,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwB/D,CAAC"}

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

@@ -18,18 +18,31 @@ $$
 ${nameFunc}(x) = ${affine.toTex()}
 $$`;
 };
-const getHint = () => {
-    return `Détermine un premier point par lequel passe la droite en utilisant l'ordonnée à l'origine de la droite. Puis à l'aide du coefficient directeur, détermine un second point à partir du premier point.`;
+const getHint = (identifiers, opts) => {
+    const { nameFunc } = identifiers;
+    if (opts?.isLinear) {
+        return `Calcule combien vaut $${nameFunc}(0)$, $${nameFunc}(1)$ et place les points correspondants. Puis trace la droite.`;
+    }
+    else {
+        return `Détermine un premier point par lequel passe la droite en utilisant l'ordonnée à l'origine de la droite. Puis à l'aide du coefficient directeur, détermine un second point à partir du premier point.`;
+    }
 };
-const getCorrection = (identifiers) => {
+const getCorrection = (identifiers, opts) => {
     const { correctA, correctB } = identifiers;
     const affine = new Affine(correctA, correctB);
-    return `Le terme constant dans l'expression $ ${affine.toTex()} $ est $${correctB}$.
-L'ordonnée à l'origine de la droite est donc $${correctB}$. 
+    return `${(() => {
+        if (opts?.isLinear) {
+            return `On a affaire à une fonction linéaire.`;
+        }
+        else {
+            return `Le terme constant dans l'expression $ ${affine.toTex()} $ est $${correctB}$.`;
+        }
+    })()}
+L'ordonnée à l'origine de la droite est donc $${correctB}$.
 La droite passe par le point de coordonnées $(0;${correctB})$.
   
 Le nombre qui multiplie $x$ dans l'expression $ ${affine.toTex()} $ est $${correctA}$.
-Le coefficient directeur de $d$ est par conséquent $${correctA}$. Donc, à partir du point $(0;${correctB})$, si l'on augmente l'abscisse de $1$ unité, l'ordonnée ${correctA < 0 ? "diminue" : "augmente"} de $${correctA}$ unité(s). La droite passe donc par le point de coordonnées $(1; ${correctB + correctA})$.
+Le coefficient directeur de $d$ est par conséquent $${correctA}$. Donc, à partir du point $(0;${correctB})$, si l'on augmente l'abscisse de $1$ unité, l'ordonnée ${correctA < 0 ? "diminue" : "augmente"} de $${Math.abs(correctA)}$ unité(s). La droite passe donc par le point de coordonnées $(1; ${correctB + correctA})$.
 
 On place donc les deux points de coordonnées $(0; ${correctB})$ et $(1; ${correctB + correctA})$, puis on trace la droite passant par ces deux points.`;
 };
@@ -83,27 +96,56 @@ const getPoint = (command, pointName) => {
     const y = +splitted[1].replace(")", "");
     return new Point(pointName, x.toTree(), y.toTree());
 };
-const getDrawAffineFromLitExpQuestion = () => {
-    const affine = AffineConstructor.random({ min: -3, max: 3 });
+const getDrawAffineFromLitExpQuestion = (opts) => {
+    let affine;
+    if (opts?.isLinear) {
+        affine = AffineConstructor.random({ min: -5, max: 5 }, { min: 0, max: 0 });
+    }
+    else {
+        affine = AffineConstructor.random({ min: -3, max: 3 });
+    }
     const nameFunc = random(["f", "g", "h"]);
     const identifiers = { correctA: affine.a, correctB: affine.b, nameFunc };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     return {
-        ggbAnswer: getGGBAnswer(identifiers),
-        instruction: getInstruction(identifiers),
-        studentGgbOptions: getStudentGGBOptions(identifiers),
+        ggbAnswer: getGGBAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        studentGgbOptions: getStudentGGBOptions(identifiers, opts),
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
     };
 };
 export const drawAffineFromLitExp = {
     id: "drawAffineFromLitExp",
-    label: "Tracer une fonction affine via son expression algébrique",
+    label: "Tracer la représentation graphique d'une fonction affine via son expression algébrique",
     isSingleStep: true,
-    generator: (nb, opts) => getDistinctQuestions(() => getDrawAffineFromLitExpQuestion(opts), nb),
+    generator: (nb) => getDistinctQuestions(() => getDrawAffineFromLitExpQuestion({ isLinear: false }), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};
+export const drawLinearFromLitExp = {
+    id: "drawLinearFromLitExp",
+    label: "Tracer la représentation graphique d'une fonction linéaire via son expression algébrique",
+    isSingleStep: true,
+    generator: (nb) => 
+    // getDistinctQuestions(
+    //   () => getDrawAffineFromLitExpQuestion({ isLinear: true }),
+    //   nb,
+    // ),
+    [...Array(nb).keys()].map(() => getDrawAffineFromLitExpQuestion({ isLinear: true })),
     ggbTimer: 60,
     isGGBAnswerValid,
     subject: "Mathématiques",

package/lib/exercises/math/functions/basics/graphicInequation.js

@@ -121,7 +121,7 @@ const getHint = (identifiers) => {
         : isStrict
             ? "strictement inférieure"
             : "inférieure";
-    return `Lit toutes les valeurs de $x$ pour lesquelles $f(x)$ est ${word} à $${yValue.frenchify()}$.`;
+    return `Lis toutes les valeurs de $x$ pour lesquelles $f(x)$ est ${word} à $${yValue.frenchify()}$.`;
 };
 const getCorrection = (identifiers) => {
     //trace droit y = y, lit x sous

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

@@ -15,4 +15,5 @@ export * from "./variations/index.js";
 export * from "./sqrt/index.js";
 export * from "./inverse/index.js";
 export * from "./composition/index.js";
+export * from "./linear/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC"}

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

@@ -15,3 +15,4 @@ export * from "./variations/index.js";
 export * from "./sqrt/index.js";
 export * from "./inverse/index.js";
 export * from "./composition/index.js";
+export * from "./linear/index.js";

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

@@ -0,0 +1,3 @@
+export * from "./linearFromExercise.js";
+export * from "./linearFromPercentageEvolution.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/linear/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC"}

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

@@ -0,0 +1,2 @@
+export * from "./linearFromExercise.js";
+export * from "./linearFromPercentageEvolution.js";

package/lib/exercises/math/functions/linear/linearFromExercise.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    situationIndex: number;
+    x1: number;
+    y1: number;
+};
+export declare const linearFromExercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=linearFromExercise.d.ts.map

package/lib/exercises/math/functions/linear/linearFromExercise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linearFromExercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/linear/linearFromExercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAsCrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAuWF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAkBpD,CAAC"}

package/lib/exercises/math/functions/linear/linearFromExercise.js

@@ -0,0 +1,355 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getRandomValues = (funcX1, funcY1, funcIsValid, defaultDict) => {
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const x1 = funcX1();
+        const y1 = funcY1(x1);
+        console.log("{x1,y1}", { x1, y1 });
+        isValid = funcIsValid(x1, y1);
+        if (isValid) {
+            return { x1, y1 };
+        }
+    }
+    return defaultDict;
+};
+const situations = [
+    //électricité
+    {
+        instruction: (x1, y1) => `Sabine a payé $${y1.frenchify()} \\ \\textrm{€}$ pour une consommation de $${x1.frenchify()} \\ \\textrm{kWh}$ d'électricité.
+  Quel aurait été le montant de sa facture (en $\\textrm{€}$) pour une consommation de $x \\ \\textrm{kWh}$ ?`,
+        hint: `Quel calcul permet de trouver le montant de la facture pour une consommation de $1 \\ \\textrm{kWh}$ ?
+
+  Inspire toi de ce calcul pour déterminer le montant de la facture pour $x \\ \\textrm{kWh}$.`,
+        correction: (x1, y1) => {
+            const nodeA = frac(y1, x1);
+            const nodeASimplified = nodeA.simplify();
+            const texASimplified = nodeASimplified.toTex();
+            const texADecimal = nodeA.simplify({ fractionsToDecimal: true }).toTex();
+            return `On modélise cette situation par une situation de proportionnalité.
+
+$$
+${nodeA.toSimplificationTex()} ${texADecimal !== texASimplified ? `= ${texADecimal}` : ""}
+$$
+
+  Pour $1 \\ \\textrm{kWh}$, Sabine paye $${texADecimal} \\ \\textrm{€}$.
+
+  La facture en $\\textrm{€}$ pour $x \\ \\textrm{kWh}$ est $${texADecimal}x$.`;
+        },
+        roundTo: 2,
+        randValues: (roundTo) => {
+            const a = randfloat(0.05, 0.25, 2);
+            const funcX1 = () => randint(1500, 5000);
+            const funcY1 = (x1) => a * x1;
+            const funcIsValid = (_, y1) => round(y1, roundTo) === y1;
+            return getRandomValues(funcX1, funcY1, funcIsValid, {
+                x1: 2000,
+                y1: 2000 * 0.2,
+            });
+        },
+    },
+    //fautes d'orthographe
+    {
+        instruction: (x1, y1) => `En $${x1.frenchify()}$ phrases, Marjorie a fait $${y1.frenchify()}$ fautes d'orthographe.
+  Quel sera le nombre vraisemblable de fautes qu'elle fera en $x$ phrases ?`,
+        hint: `Quel calcul permet de trouver le nombre de fautes dans $1$ phrase ?
+
+  Inspire toi de ce calcul pour déterminer le nombre de fautes en $x$ phrases.`,
+        correction: (x1, y1) => {
+            const nodeA = frac(y1, x1);
+            const nodeASimplified = nodeA.simplify();
+            const texASimplified = nodeASimplified.toTex();
+            const texSimplification = nodeA.toSimplificationTex();
+            return `On modélise cette situation par une situation de proportionnalité.
+
+${(() => {
+                if (texSimplification.includes("=")) {
+                    return `
+
+$$
+${texSimplification}
+$$
+    
+`;
+                }
+                else {
+                    return ``;
+                }
+            })()}
+
+  En $1$ phrase, Marjorie fait $${texASimplified}$ fautes.
+
+  Le nombre de fautes vraisemblablement attendu en $x$ phrases est $${texASimplified}x$.`;
+        },
+        roundTo: -1,
+        randValues: (_) => {
+            const a = randint(2, 13);
+            const funcX1 = () => randint(2, 6);
+            const funcY1 = (x1) => a * x1;
+            const funcIsValid = () => true;
+            return getRandomValues(funcX1, funcY1, funcIsValid, {
+                x1: 2,
+                y1: 11,
+            });
+        },
+    },
+    //volume d'air inspiré
+    {
+        instruction: (x1, y1) => `En $${x1.frenchify()} \\ \\textrm{h}$, Julia a inspiré $${y1.frenchify()} \\ \\textrm{L}$ d'air.
+  Quel est le volume d'air qu'elle inspire en $x \\ \\textrm{h}$  ?`,
+        hint: `Quel calcul permet de trouver le volume inspiré en $1 \\ \\textrm{h}$ ?
+
+  Inspire toi de ce calcul pour déterminer le volume inspiré en $x \\ \\textrm{h}$.`,
+        correction: (x1, y1) => {
+            const nodeA = frac(y1, x1);
+            const nodeASimplified = nodeA.simplify();
+            const texASimplified = nodeASimplified.toTex();
+            const texSimplification = nodeA.toSimplificationTex();
+            return `On modélise cette situation par une situation de proportionnalité.
+
+${(() => {
+                if (texSimplification.includes("=")) {
+                    return `
+
+$$
+${texSimplification}
+$$
+    
+`;
+                }
+                else {
+                    return ``;
+                }
+            })()}
+
+  En $1 \\ \\textrm{h}$, Julia inspire $${texASimplified} \\ \\textrm{L}$ d'air.
+
+  Le volume d'air vraisemblablement inspiré en litres en $x \\ \\textrm{h}$ est $${texASimplified}x$.`;
+        },
+        roundTo: 0,
+        randValues: (_) => {
+            const a = randint(400, 500);
+            const funcX1 = () => 24;
+            const funcY1 = (x1) => a * x1;
+            const funcIsValid = () => true;
+            return getRandomValues(funcX1, funcY1, funcIsValid, {
+                x1: 24,
+                y1: 13045,
+            });
+        },
+    },
+    //safran
+    {
+        instruction: (x1, y1) => `Pour $${x1.frenchify()} \\ \\textrm{g}$ de safran, Justin a payé  $${y1.frenchify()} \\ \\textrm{€}$.
+Quel est le prix en $\\textrm{€}$ pour $x \\ \\textrm{g}$ ?`,
+        hint: `Quel calcul permet de trouver le prix pour $1 \\ \\textrm{g}$ ?
+    
+Inspire toi de ce calcul pour déterminer le prix pour $x \\ \\textrm{€}$.`,
+        correction: (x1, y1) => {
+            const nodeA = frac(y1, x1);
+            const nodeASimplified = nodeA.simplify();
+            const texASimplified = nodeASimplified.toTex();
+            const texADecimal = nodeA.simplify({ fractionsToDecimal: true }).toTex();
+            return `On modélise cette situation par une situation de proportionnalité.
+
+$$
+${nodeA.toSimplificationTex()} ${texADecimal !== texASimplified ? `= ${texADecimal}` : ""}
+$$
+
+Pour $1 \\ \\textrm{g}$, le prix est de $${texADecimal} \\ \\textrm{€}$.
+
+Le prix en $\\textrm{€}$ pour $x \\ \\textrm{g}$ est $${texADecimal}x$.`;
+        },
+        roundTo: 2,
+        randValues: (roundTo) => {
+            const a = randint(10, 46);
+            const funcX1 = () => round(randint(2, 201) * 0.05, 2);
+            const funcY1 = (x1) => a * x1;
+            const funcIsValid = (_, y1) => round(y1, roundTo) === y1;
+            return getRandomValues(funcX1, funcY1, funcIsValid, {
+                x1: 0.35,
+                y1: 5.6,
+            });
+        },
+    },
+    //autoroute
+    {
+        instruction: (_, y1) => `Sur l'autoroute, Anton roule à une vitesse constante de $${y1.frenchify()} \\ \\textrm{km/h}$.
+Quelle est la distance parcourue en $\\textrm{km}$ pour $x \\ \\textrm{h}$ ?`,
+        hint: `Quel calcul permet de trouver la distance parcourue en $1 \\ \\textrm{h}$ ?
+    
+Inspire toi de ce calcul pour déterminer la distance parcourue en $x \\ \\textrm{h}$.`,
+        correction: (x1, y1) => {
+            const nodeA = frac(y1, x1);
+            const texADecimal = nodeA.simplify({ fractionsToDecimal: true }).toTex();
+            return `On modélise cette situation par une situation de proportionnalité.
+
+En $1 \\ \\textrm{h}$, Anton parcourt $${texADecimal} \\ \\textrm{km}$.
+
+La distance parcourue en $\\textrm{km}$ en $x \\ \\textrm{h}$ est $${texADecimal}x$.`;
+        },
+        roundTo: 2,
+        randValues: (roundTo) => {
+            const a = randint(80, 130);
+            const funcX1 = () => 1;
+            const funcY1 = (x1) => a * x1;
+            const funcIsValid = (_, y1) => round(y1, roundTo) === y1;
+            return getRandomValues(funcX1, funcY1, funcIsValid, {
+                x1: 1,
+                y1: 101,
+            });
+        },
+    },
+    //fientes de pigeon
+    {
+        instruction: (_, y1) => `Dans un village de France, l'église reçoit $${y1.frenchify()} \\ \\textrm{g}$ de fientes de pigeon chaque semaine.
+Quel est la masse de fientes de pigeon en $\\textrm{g}$ pour $x$ jours ?`,
+        hint: `Quel calcul permet de trouver la masse reçue en $1$ jour ?
+    
+Inspire toi de ce calcul pour déterminer la masse reçue en $x \\ \\textrm{h}$.`,
+        correction: (x1, y1) => {
+            const nodeA = frac(y1, x1);
+            const texADecimal = nodeA.simplify({ fractionsToDecimal: true }).toTex();
+            return `On modélise cette situation par une situation de proportionnalité.
+
+En $1$ jour, l'église reçoit $${texADecimal} \\ \\textrm{g}$.
+
+La masse reçue en $\\textrm{g}$ en $x$ jours est $${texADecimal}x$.`;
+        },
+        roundTo: 0,
+        randValues: (roundTo) => {
+            const a = randint(10, 120);
+            const funcX1 = () => 7;
+            const funcY1 = (x1) => a * x1;
+            const funcIsValid = (_, y1) => round(y1, roundTo) === y1;
+            return getRandomValues(funcX1, funcY1, funcIsValid, {
+                x1: 30,
+                y1: 7,
+            });
+        },
+    },
+];
+const getInstruction = (identifiers) => {
+    const { situationIndex, x1, y1 } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.instruction(x1, y1);
+};
+const getAnswerNode = (identifiers) => {
+    const { x1, y1 } = identifiers;
+    const nodeA = frac(y1, x1).simplify();
+    return multiply(nodeA, new VariableNode("x"));
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { situationIndex } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.hint;
+};
+const getCorrection = (identifiers) => {
+    const { situationIndex, x1, y1 } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.correction(x1, y1);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return parseAlgebraic(ans)
+        .simplify()
+        .equals(parseAlgebraic(answer).simplify());
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { x1, y1 } = identifiers;
+    addValidProp(propositions, answer);
+    //wrong frac
+    const fractionNodeWrong = frac(x1, y1).simplify();
+    tryToAddWrongProp(propositions, multiply(fractionNodeWrong, new VariableNode("x")).toTex());
+    //terror (around answer or around wrong)
+    const nodeRight = frac(y1, x1).simplify();
+    const [xS, yS] = (() => {
+        if (isFractionNode(nodeRight)) {
+            const fractionNodeRight = nodeRight;
+            return [
+                fractionNodeRight.leftChild.evaluate(),
+                fractionNodeRight.rightChild.evaluate(),
+            ];
+        }
+        else {
+            return [nodeRight.evaluate(), 1];
+        }
+    })();
+    [
+        random([
+            //around right
+            frac(Math.max(1, yS + randint(-10, 11, [0])), xS).simplify(),
+            //around wrong
+            frac(Math.max(1, xS + randint(-10, 11, [0])), yS).simplify(),
+        ]),
+    ].forEach((fractionNodeWrong) => {
+        tryToAddWrongProp(propositions, multiply(fractionNodeWrong, new VariableNode("x")).toTex());
+    });
+    const wrongPropsFiller = shuffle([
+        //linear (l'âge du capitaine)
+        multiply(x1, new VariableNode("x")).toTex(),
+        multiply(y1, new VariableNode("x")).toTex(),
+        //affine (l'âge du capitaine)
+        add(x1, multiply(y1, new VariableNode("x"))).toTex(),
+        add(y1, multiply(x1, new VariableNode("x"))).toTex(),
+    ]);
+    function* genFuncWrongPropFiller() {
+        yield* wrongPropsFiller;
+        return "Done";
+    }
+    const generateWrongPropsFiller = genFuncWrongPropFiller();
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, generateWrongPropsFiller.next().value);
+    });
+    return shuffleProps(propositions, n);
+};
+const getLinearFromExerciseQuestion = () => {
+    const situationIndex = randint(0, situations.length);
+    const situation = situations[situationIndex];
+    const { x1, y1 } = situation.randValues(situation.roundTo);
+    const identifiers = { situationIndex, x1, y1 };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const linearFromExercise = {
+    id: "linearFromExercise",
+    label: "Modéliser une situation de proportionnalité par une fonction linéaire",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getLinearFromExerciseQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/linear/linearFromPercentageEvolution.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    situationIndex: number;
+    numP: number;
+};
+export declare const linearFromPercentageEvolution: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=linearFromPercentageEvolution.d.ts.map

package/lib/exercises/math/functions/linear/linearFromPercentageEvolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linearFromPercentageEvolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/linear/linearFromPercentageEvolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAyRF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}

package/lib/exercises/math/functions/linear/linearFromPercentageEvolution.js

@@ -0,0 +1,233 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.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 { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const situations = [
+    //+
+    //électricité
+    {
+        instruction: (numP) => `Pour Sabine, le prix du $\\textrm{kWh}$ a augmenté de $${numP} \\ \\%$.
+On appelle $x$ le prix du $\\textrm{kWh}$ avant l'augmentation et $f$ la fonction qui, à $x$, associe son prix après l'augmentation.
+Exprimer $f(x)$ en fonction de $x$.`,
+        hint: `Suppose que Sabine payait $100 \\ \\textrm{€}$ et que sa consommation d'électricité reste la même. Quel est le prix qu'elle paiera après l'augmentation ?
+  Inspire toi de ce calcul pour déterminer l'expression de $f(x)$.`,
+        correction: `L'ancien prix est $x$. Le nouveau prix est $f(x)$.`,
+        randValues: () => {
+            const numP = randint(4, 350);
+            return { numP };
+        },
+    },
+    //-
+    //industriel
+    {
+        instruction: (numP) => `Dans la nouvelle recette de biscuit d'un industriel, la masse de sucre a baissé de $${Math.abs(numP)} \\ \\%$.
+On appelle $x$ la masse de sucre dans l'ancienne recette et $f$ la fonction qui, à $x$, associe la masse de sucre dans la nouvelle recette.
+Exprimer $f(x)$ en fonction de $x$.`,
+        hint: `Suppose qu'un biscuit contenait $100 \\ \\textrm{g}$ de sucre avant, combien en contient-il maintenant ?
+
+  Inspire toi de ce calcul pour déterminer l'expression de $f(x)$.`,
+        correction: `L'ancienne masse est $x$. La nouvelle masse est $f(x)$.`,
+        randValues: () => {
+            const numP = -randint(20, 61);
+            return { numP };
+        },
+    },
+    //+ ou -
+    //casque
+    {
+        instruction: (numP) => `Erika a un nouveau casque sans fil. L'autonomie, par rapport à l'ancien casque, a ${numP < 0 ? "diminué" : "augmenté"} de $${Math.abs(numP)} \\ \\%$.
+On appelle $x$ l'autonomie de l'ancien casque et $f$ la fonction qui, à $x$, associe l'autonomie du nouveau casque.
+Exprimer $f(x)$ en fonction de $x$.`,
+        hint: `Suppose que l'autonomie de l'ancien casque était de $100 \\ \\textrm{h}$, quelle est celle du nouveau casque ?
+
+  Inspire toi de ce calcul pour déterminer l'expression de $f(x)$.`,
+        correction: `L'ancienne autonomie est $x$. La nouvelle autonomie est $f(x)$.`,
+        randValues: () => {
+            const numP = coinFlip() ? randint(-50, -15) : randint(15, 50);
+            return { numP };
+        },
+    },
+    //rpg
+    {
+        instruction: (numP) => `Dans un jeu vidéo, Maelle a changé l'équipement de son personnage. La caractéristique "vitesse", par rapport à l'ancien équipement a ${numP < 0 ? "diminué" : "augmenté"} de $${Math.abs(numP)} \\ \\%$.
+On appelle $x$ la vitesse précédente et $f$ la fonction qui, à $x$, associe la nouvelle vitesse.
+Exprimer $f(x)$ en fonction de $x$.`,
+        hint: `Suppose que l'ancienne vitesse était $100$, quelle est la nouvelle vitesse ?
+
+  Inspire toi de ce calcul pour déterminer l'expression de $f(x)$.`,
+        correction: `L'ancienne vitesse est $x$. La nouvelle vitesse est $f(x)$.`,
+        randValues: () => {
+            const numP = coinFlip() ? randint(-50, -15) : randint(15, 50);
+            return { numP };
+        },
+    },
+    //course à pied
+    {
+        instruction: (numP) => `Vladimir s'entraîne à la course à pied. Par rapport à la séance précédente, son chrono au $10 \\ \\textrm{km}$ a ${numP < 0 ? "diminué" : "augmenté"} de $${Math.abs(numP)} \\ \\%$.
+On appelle $x$ la durée précédente et $f$ la fonction qui, à $x$, associe la nouvelle durée.
+Exprimer $f(x)$ en fonction de $x$.`,
+        hint: `Suppose que l'ancienne durée était $10$ min, quelle est la nouvelle durée ?
+
+  Inspire toi de ce calcul pour déterminer l'expression de $f(x)$.`,
+        correction: `L'ancienne durée est $x$. La nouvelle durée est $f(x)$.`,
+        randValues: () => {
+            const numP = coinFlip() ? randint(-50, -15) : randint(15, 50);
+            return { numP };
+        },
+    },
+    //livre
+    {
+        instruction: (numP) => `Un illustre écrivain sort un nouveau livre. Par rapport au dernier livre, le nombre de pages a ${numP < 0 ? "diminué" : "augmenté"} de $${Math.abs(numP)} \\ \\%$.
+On appelle $x$ le nombre de pages du livre précédent et $f$ la fonction qui, à $x$, associe le nombre de pages du nouveau livre.
+Exprimer $f(x)$ en fonction de $x$.`,
+        hint: `Suppose que l'ancien nombre de pages était $100$, quelle est le nouveau nombre de pages ?
+
+  Inspire toi de ce calcul pour déterminer l'expression de $f(x)$.`,
+        correction: `L'ancien nombre de pages est $x$. Le nouveau nombre de pages est $f(x)$.`,
+        randValues: () => {
+            const numP = coinFlip() ? randint(-50, -15) : randint(15, 50);
+            return { numP };
+        },
+    },
+];
+const getInstruction = (identifiers) => {
+    const { situationIndex, numP } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.instruction(numP);
+};
+const getAnswerNode = (identifiers) => {
+    const { numP } = identifiers;
+    const nodeFactor = add(1, frac(numP, 100));
+    const nodeFactorSimplifiedDecimal = nodeFactor.simplify({
+        fractionsToDecimal: true,
+    });
+    const nodeExprSimplified = multiply(nodeFactorSimplifiedDecimal, new VariableNode("x"));
+    return nodeExprSimplified;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { situationIndex } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.hint;
+};
+const getCorrection = (identifiers) => {
+    const { situationIndex, numP } = identifiers;
+    const situation = situations[situationIndex];
+    const texCorrection = situation.correction;
+    const nodeFractionP = frac(numP, 100);
+    const nodeFactor = add(1, nodeFractionP);
+    const nodeFactorSimplified = nodeFactor.simplify();
+    const texFactorDecimal = nodeFactorSimplified
+        .simplify({ fractionsToDecimal: true })
+        .toTex();
+    const nodeExpr = multiply(nodeFactor, new VariableNode("x"));
+    return `${texCorrection} 
+
+${alignTex([
+        ["f(x)", "=", nodeExpr.toTex()],
+        ["", "=", `${texFactorDecimal} x`],
+    ])}
+      
+La fonction $f$ est donc une fonction linéaire de coefficient $${texFactorDecimal}$.`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    return parseAlgebraic(ans)
+        .simplify()
+        .equals(parseAlgebraic(answer).simplify());
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { numP } = identifiers;
+    addValidProp(propositions, answer);
+    //(1+numP/100) -> numP/100
+    tryToAddWrongProp(propositions, multiply(frac(numP, 100).simplify({
+        fractionsToDecimal: true,
+    }), new VariableNode("x")).toTex());
+    //mult
+    tryToAddWrongProp(propositions, multiply(numP, new VariableNode("x")).toTex());
+    //terror (around answer or around wrong)
+    const numP10Around = (() => {
+        if (numP % 10 === 0) {
+            return numP / 10;
+        }
+        else {
+            return numP * 10;
+        }
+    })();
+    if (coinFlip()) {
+        tryToAddWrongProp(propositions, multiply(frac(100 + numP10Around, 100).simplify({
+            fractionsToDecimal: true,
+        }), new VariableNode("x")).toTex());
+    }
+    else {
+        tryToAddWrongProp(propositions, multiply(frac(numP10Around, 100).simplify({
+            fractionsToDecimal: true,
+        }), new VariableNode("x")).toTex());
+    }
+    //forgets x
+    //terror 2 (around answer or around wrong)
+    if (coinFlip()) {
+        const fractionNode = random([
+            frac(100 + numP, 100),
+            frac(100 + numP10Around, 100),
+        ]);
+        tryToAddWrongProp(propositions, fractionNode
+            .simplify({
+            fractionsToDecimal: true,
+        })
+            .toTex());
+    }
+    else {
+        const fractionNode = random([frac(numP, 100), frac(numP10Around, 100)]);
+        tryToAddWrongProp(propositions, fractionNode
+            .simplify({
+            fractionsToDecimal: true,
+        })
+            .toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getLinearFromPercentageEvolutionQuestion = () => {
+    const situationIndex = randint(0, situations.length);
+    const situation = situations[situationIndex];
+    const { numP } = situation.randValues();
+    const identifiers = { situationIndex, numP };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const linearFromPercentageEvolution = {
+    id: "linearFromPercentageEvolution",
+    label: "Modéliser une évolution en pourcentage par une fonction linéaire",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getLinearFromPercentageEvolutionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/trinoms/devForm/coefficientsIdentification.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coefficientsIdentification.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/devForm/coefficientsIdentification.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA6IF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}
+{"version":3,"file":"coefficientsIdentification.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/devForm/coefficientsIdentification.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA2IF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}

package/lib/exercises/math/functions/trinoms/devForm/coefficientsIdentification.js

@@ -7,9 +7,9 @@ import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.js";
 import { isFractionNode } from "../../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
 import { square } from "../../../../../tree/nodes/operators/powerNode.js";
-import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
 import { random } from "../../../../../utils/alea/random.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { rationalVEA } from "../../../../../exercises/vea/rationalVEA.js";
 const getPropositions = (n, { answer, aIdentifiers, bIdentifiers, cIdentifiers, isAsking }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -71,10 +71,7 @@ const getKeys = () => {
 };
 const isAnswerValid = (ans, { answer }) => {
     try {
-        const parsed = parseAlgebraic(ans);
-        if (!parsed)
-            return false;
-        return parsed.simplify().toTex() === answer;
+        return rationalVEA(ans, answer);
     }
     catch (err) {
         return handleVEAError(err);

package/lib/index.d.ts

@@ -1045,9 +1045,12 @@ declare const mathExercises: (Exercise<{
     b: number;
     askingPositive: boolean;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    isLinear: boolean;
     b: number;
     secondPoint: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    isLinear: boolean;
+}> | Exercise<{
     b: number;
     secondPoint: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -1084,7 +1087,9 @@ declare const mathExercises: (Exercise<{
     correctA: number;
     correctB: number;
     nameFunc: string;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    isLinear: boolean;
+}> | Exercise<{
     items: {
         fName: string;
         tex: string;
@@ -1593,6 +1598,13 @@ declare const mathExercises: (Exercise<{
         tex: string;
         isValid: boolean;
     }[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situationIndex: number;
+    x1: number;
+    y1: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situationIndex: number;
+    numP: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     coin: boolean;
     radius: number;
@@ -3575,9 +3587,12 @@ declare const pcExercises: (Exercise<{
     equaDiffIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     isSolution: boolean;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    isLinear: boolean;
     b: number;
     secondPoint: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    isLinear: boolean;
+}> | Exercise<{
     tenthPower: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/package.json

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