math-exercises 3.0.125 → 3.0.127

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

@@ -0,0 +1,117 @@
+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 { equationResolutionTex } from "../../../../tree/nodes/equations/equalNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { pointParser } from "../../../../tree/parsers/pointParser.js";
+const getInstruction = (identifiers) => {
+    const { yValue, coeffs } = identifiers;
+    const affine = AffineConstructor.fromCoeffs(coeffs);
+    return `Le point $M$ d'ordonnée $${yValue}$ appartient à la courbe d'équation 
+
+$$
+y=${affine.toTex()} 
+$$
+
+Quelles sont les coordonnées de $M$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { yValue, coeffs } = identifiers;
+    const polynome = AffineConstructor.fromCoeffs(coeffs);
+    const xValue = polynome.solve(yValue);
+    const answer = `(${xValue.toTex()};${yValue.frenchify()})`;
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { yValue, 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 donc résoudre l'équation : 
+  
+$$
+${affine.toTex()} = ${yValue} 
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { yValue, coeffs } = identifiers;
+    const affine = new Affine(coeffs[1], coeffs[0], "x_{M}");
+    const answer = getAnswer(identifiers);
+    return `On résout l'équation : 
+  
+$$
+${affine.toTex()} = ${yValue} 
+$$
+
+On obtient : 
+
+$$
+${equationResolutionTex(coeffs[1].toTree(), coeffs[0].toTree(), (0).toTree(), yValue.toTree(), "x_{M}")}
+$$
+
+Les coordonnées de $M$ sont donc $${answer}$.`;
+};
+const getPropositions = (n, { answer, coeffs, yValue }) => {
+    const [p, m] = coeffs;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const poly = AffineConstructor.fromCoeffs(coeffs);
+    tryToAddWrongProp(propositions, `(${yValue.frenchify()}, ${poly.calculate(yValue).frenchify()})`);
+    tryToAddWrongProp(propositions, `(${yValue}, ${AffineConstructor.fromCoeffs([p, -m])
+        .calculate(yValue)
+        .frenchify()})`);
+    tryToAddWrongProp(propositions, `(${frac(add(yValue, p), m).simplify().toTex()}, ${yValue.frenchify()})`);
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const pointAns = pointParser(ans);
+    if (!pointAns) {
+        return false;
+    }
+    const pointAnswer = pointParser(answer);
+    return [
+        [pointAns.x, pointAnswer.x],
+        [pointAns.y, pointAnswer.y],
+    ].every(([nodeAns, nodeAnswer]) => substract(nodeAns, nodeAnswer).evaluate() === 0);
+};
+const getCoordsOfPointOnAffineFindXQuestion = () => {
+    const polynome1 = new Polynomial([randint(-9, 10), randint(-5, 6, [0])]);
+    const xValue = randint(-9, 10);
+    const y = polynome1.calculate(xValue);
+    const identifiers = { coeffs: polynome1.coefficients, yValue: y };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["semicolon"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const coordsOfPointOnAffineFindX = {
+    id: "coordsOfPointOnAffineFindX",
+    label: "Déterminer les coordonnées d'un point appartenant à une droite et dont on connaît l'ordonnée",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getCoordsOfPointOnAffineFindXQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+    getPropositions,
+    isAnswerValid,
+};

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

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

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,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA+HF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAe5D,CAAC"}

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

@@ -0,0 +1,118 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point } from "../../../../math/geometry/point.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";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { pointParser } from "../../../../tree/parsers/pointParser.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 getAnswerPoint = (identifiers) => {
+    const { xValue, coeffs } = identifiers;
+    const polynome = AffineConstructor.fromCoeffs(coeffs);
+    const yValue = polynome.calculate(xValue);
+    return new Point("A", xValue, yValue);
+};
+const getAnswer = (identifiers) => {
+    const answerPoint = getAnswerPoint(identifiers);
+    const answer = `(${answerPoint.x.toTex()};${answerPoint.y.toTex()})`;
+    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 isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const pointAns = pointParser(ans);
+    if (!pointAns)
+        return false;
+    const pointAnswer = getAnswerPoint(identifiers);
+    return [
+        [pointAns.x, pointAnswer.x],
+        [pointAns.y, pointAnswer.y],
+    ].every(([ansNode, answerNode]) => substract(ansNode, answerNode).simplify().evaluate() === 0);
+};
+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: ["semicolon"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const coordsOfPointOnAffineFindY = {
+    id: "coordsOfPointOnAffineFindY",
+    label: "Déterminer les coordonnées d'un point appartenant à une droite et dont on connaît l'abscisse",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getCoordsOfPointOnAffineFindYQuestion, nb),
+    getPropositions,
+    isAnswerValid,
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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;AAOzC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,mBAAmB,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA+NF,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"}