math-exercises 3.0.145 → 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"}