math-exercises 3.0.20 → 3.0.21

package/lib/exercises/math/dataRepresentations/barChartReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"barChartReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/barChartReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC"}
+{"version":3,"file":"barChartReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/barChartReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC"}

package/lib/exercises/math/dataRepresentations/barChartReading.js

@@ -72,7 +72,6 @@ const getInstruction = (identifiers) => {
         .attr("width", xScale.bandwidth())
         .attr("height", (d) => height - margin.bottom - yScale(d.sales))
         .attr("fill", "steelblue");
-    console.log(d3n.svgString());
     const svgString = d3n.svgString();
     return `BBteeeezfst : 
 

package/lib/exercises/math/dataRepresentations/functionGraphReading.d.ts

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

package/lib/exercises/math/dataRepresentations/functionGraphReading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionGraphReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/functionGraphReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoLF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}

package/lib/exercises/math/dataRepresentations/functionGraphReading.js

@@ -0,0 +1,174 @@
+import { addValidProp, shuffleProps, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
+import { Affine } from "../../../math/polynomials/affine.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
+import { D3Node } from "d3-node";
+import katex from "katex";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        throw Error("QCM not implemented");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b, yValue } = identifiers;
+    return round((yValue - b) / a, 0).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { yValue, a, b } = identifiers;
+    const width = 600;
+    const height = 300;
+    const margin = { top: 20, right: 20, bottom: 40, left: 50 };
+    const d3n = new D3Node();
+    const d3 = d3n.d3;
+    const svg = d3n.createSVG(width, height);
+    const xScale = d3
+        .scaleLinear()
+        .domain([0, 60])
+        .range([margin.left, width - margin.right]);
+    const yScale = d3
+        .scaleLinear()
+        .domain([0, 8000])
+        .range([height - margin.bottom, margin.top]);
+    const xAxis = d3.axisBottom(xScale).ticks(30).tickValues(d3.range(0, 61, 2));
+    const yAxis = d3
+        .axisLeft(yScale)
+        .ticks(16)
+        .tickValues(d3.range(0, 8500, 500));
+    svg
+        .append("g")
+        .attr("transform", `translate(0,${height - margin.bottom})`)
+        .call(xAxis);
+    svg.append("g").attr("transform", `translate(${margin.left},0)`).call(yAxis);
+    // Gridlines
+    const gridlinesX = d3
+        .axisBottom(xScale)
+        .tickSize(-height + margin.top + margin.bottom)
+        .tickFormat(() => "")
+        .tickValues(d3.range(0, 61, 2));
+    const gridlinesY = d3
+        .axisLeft(yScale)
+        .tickSize(-width + margin.left + margin.right)
+        .tickFormat(() => "")
+        .tickValues(d3.range(0, 8500, 500));
+    svg
+        .append("g")
+        .attr("class", "grid")
+        .attr("transform", `translate(0,${height - margin.bottom})`)
+        .call(gridlinesX);
+    svg
+        .append("g")
+        .attr("class", "grid")
+        .attr("transform", `translate(${margin.left},0)`)
+        .call(gridlinesY);
+    // Line
+    const line = d3
+        .line()
+        .x((d) => xScale(d))
+        .y((d) => yScale(d * a + b));
+    svg
+        .append("path")
+        .datum(d3.range(0, 61))
+        .attr("fill", "none")
+        .attr("stroke", "blue")
+        .attr("stroke-width", 1)
+        .attr("d", line);
+    // KaTeX math expression
+    const latexString = katex.renderToString("(d_1)", { throwOnError: false });
+    svg
+        .append("foreignObject")
+        .attr("x", xScale(18))
+        .attr("y", yScale(4500))
+        .attr("width", 50)
+        .attr("height", 30)
+        .html(`<div style='font-size: 16px; font-weight: bold'>${latexString}</div>`);
+    // Labels
+    svg
+        .append("text")
+        .attr("x", width / 2)
+        .attr("y", height - 5)
+        .attr("text-anchor", "middle")
+        .attr("font-weight", "bold")
+        .text("Nombre de participants");
+    svg
+        .append("text")
+        .attr("x", margin.left)
+        .attr("y", margin.top - 5)
+        .attr("text-anchor", "middle")
+        .attr("font-weight", "bold")
+        .text("Coût en €");
+    return `La droite $(d_1)$ modélise l'évolution du coût total d'un voyage scolaire en fonction du nombre de participants.
+    
+Si le coût total du voyage est de $${yValue}€$, quel est le nombre de participants ?
+
+${d3n.svgString()}`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBOptions = (identifiers) => {
+    const { a, b, yValue } = identifiers;
+    const affine = new Affine(a, b);
+    const ggb = new GeogebraConstructor({
+        commands: [`Function(${a}*x+${b}, 0, 10000)`],
+        forbidShiftDragZoom: true,
+        gridDistance: [2, 500],
+        lockedAxesRatio: 2 / 500,
+        xAxis: {
+            label: "Nombre de participants",
+            steps: 2,
+            showPositive: true,
+        },
+        yAxis: {
+            label: "Coût en €",
+            steps: 500,
+            showPositive: true,
+        },
+    });
+    return ggb.getOptions({
+        coords: [-5, 65, -5, 8500],
+    });
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    throw Error("VEA not implemented");
+};
+const getFunctionGraphReadingQuestion = (opts) => {
+    const a = randint(50, 300);
+    const b = randint(0, 300);
+    const yValue = 500 * randint(1, 16);
+    const identifiers = { a, b, yValue };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const functionGraphReading = {
+    id: "functionGraphReading",
+    label: "",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFunctionGraphReadingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+};

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

@@ -1,2 +1,3 @@
 export * from "./tableReading.js";
 // export * from "./barChartReading.js";
+// export * from "./functionGraphReading.js";

package/lib/exercises/math/derivation/derivative/inflexionPointQuadrinomials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inflexionPointQuadrinomials.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/inflexionPointQuadrinomials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAiGF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAa7D,CAAC"}
+{"version":3,"file":"inflexionPointQuadrinomials.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/inflexionPointQuadrinomials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAsJF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAkB7D,CAAC"}

package/lib/exercises/math/derivation/derivative/inflexionPointQuadrinomials.js

@@ -1,11 +1,32 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
 import { Polynomial, PolynomialConstructor, } from "../../../../math/polynomials/polynomial.js";
 import { Trinom } from "../../../../math/polynomials/trinom.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { equationResolutionTex } from "../../../../tree/nodes/equations/equalNode.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = ({ quadcoeffs }) => {
+    const quadrinomial = new Polynomial(quadcoeffs);
+    return `Soit la fonction $f$ définie par : 
+  
+$$
+f(x) = ${quadrinomial.toTex()}
+$$
+
+Calculer l'abscisse de son point d'inflexion.`;
+};
+const getAnswer = ({ quadcoeffs }) => {
+    const quadrinomial = new Polynomial(quadcoeffs);
+    const secondderivative = quadrinomial.derivate().derivate();
+    const seconddcoeffs = secondderivative.coefficients;
+    return new FractionNode(new MultiplyNode(seconddcoeffs[0].toTree(), new NumberNode(-1)), seconddcoeffs[1].toTree())
+        .simplify()
+        .toTex();
+};
 const getInflexionPointQuadrinomialsQuestion = () => {
     let quadrinomial;
     let quadcoeffs;
@@ -13,17 +34,15 @@ const getInflexionPointQuadrinomialsQuestion = () => {
         quadrinomial = PolynomialConstructor.randomWithOrder(3);
         quadcoeffs = quadrinomial.coefficients;
     } while (quadcoeffs[1] === 0 || quadcoeffs[2] === 0);
-    const secondderivative = quadrinomial.derivate().derivate();
-    const seconddcoeffs = secondderivative.coefficients;
-    const inflexionPoint = new FractionNode(new MultiplyNode(seconddcoeffs[0].toTree(), new NumberNode(-1)), seconddcoeffs[1].toTree())
-        .simplify()
-        .toTex();
+    const identifiers = { quadcoeffs };
     const question = {
-        answer: inflexionPoint,
-        instruction: `Soit la fonction $f(x) = ${quadrinomial.toTex()}$. Calculer l'abscisse de son point d'inflexion.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { quadcoeffs },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -56,14 +75,44 @@ const getPropositions = (n, { answer, quadcoeffs }) => {
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer, quadcoeffs }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getHint = ({ quadcoeffs }) => {
     const quadrinomial = new Polynomial(quadcoeffs);
-    const secondderivative = quadrinomial.derivate().derivate();
-    const seconddcoeffs = secondderivative.coefficients;
+    return `Pour trouver l'abscisse du point d'inflexion, on doit résoudre l'équation $f''(x) = 0$.`;
+};
+const getCorrection = ({ quadcoeffs }) => {
+    const quadrinomial = new Polynomial(quadcoeffs);
+    const firstDerivative = quadrinomial.derivate();
+    const secondDerivative = firstDerivative.derivate();
+    const seconddcoeffs = secondDerivative.coefficients;
     const inflexionPoint = new FractionNode(new MultiplyNode(seconddcoeffs[0].toTree(), new NumberNode(-1)), seconddcoeffs[1].toTree()).simplify();
-    const latexs = inflexionPoint.toAllValidTexs({
-        allowFractionToDecimal: true,
-    });
-    return latexs.includes(ans);
+    return `Le point d'inflexion est l'abscisse où la dérivée seconde s'annule.
+
+- La dérivée première est :
+
+$$
+f'(x) = ${firstDerivative.toTex()}
+$$
+
+- La dérivée seconde est :
+
+$$
+f''(x) = ${secondDerivative.toTex()}
+$$
+
+- Résolvons $f''(x) = 0$ :
+   
+$$
+${equationResolutionTex(seconddcoeffs[1].toTree(), seconddcoeffs[0].toTree(), (0).toTree(), (0).toTree())}
+$$
+
+L'abscisse du point d'inflexion est donc $${inflexionPoint.toTex()}$.`;
 };
 export const inflexionPointQuadrinomials = {
     id: "inflexionPointQuadrinomials",
@@ -77,4 +126,9 @@ export const inflexionPointQuadrinomials = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/exponential/expFactorization.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+    uA: number;
+};
+export declare const expFactorization: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=expFactorization.d.ts.map

package/lib/exercises/math/functions/exponential/expFactorization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expFactorization.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponential/expFactorization.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAwJF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAiBlD,CAAC"}

package/lib/exercises/math/functions/exponential/expFactorization.js

@@ -0,0 +1,147 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+// import { expressionVEA } from "#root/exercises/vea/expressionVEA.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { isMultiplyNode, multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
+// import { variable } from "../../../../tree/nodes/variables/variableNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { uA } = identifiers;
+    addValidProp(propositions, answer);
+    const expNode = exp(multiply(uA, "x"));
+    while (propositions.length < n) {
+        const affine = AffineConstructor.random();
+        tryToAddWrongProp(propositions, multiply(affine.toTree(), expNode).toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const { a, b, c, d, e, f, uA } = identifiers;
+    const expNode = exp(multiply(uA, "x"));
+    const firstTerm = multiply(a, add(multiply(b, "x"), c)).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const secondTerm = multiply(d, add(multiply(e, "x"), f)).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const factor = add(firstTerm, secondTerm).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    return multiply(factor, expNode);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { a, b, c, d, e, f, uA } = identifiers;
+    const expNode = exp(multiply(uA, "x"));
+    const node = add(multiply(a, multiply(add(multiply(b, "x"), c).simplify({
+        forbidFactorize: true,
+    }), expNode)), multiply(d, multiply(add(multiply(e, "x"), f).simplify({
+        forbidFactorize: true,
+    }), expNode)));
+    return `Factoriser l'expression suivante :
+  
+$$
+${node.toTex()}
+$$`;
+};
+// const getHint: GetHint<Identifiers> = () => {
+//   return `Pour factoriser une expression avec des exponentielles :
+//   1) Repérer le facteur exponentiel commun
+//   2) Mettre en facteur $e^{u(x)}$
+//   3) Factoriser l'expression entre parenthèses`;
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   const operator = isAdd ? "+" : "-";
+//   const step1 = `(${a}x${b >= 0 ? "+" : ""}${b})e^{${u}} ${operator} (${c}x${
+//     d >= 0 ? "+" : ""
+//   }${d})e^{${u}}`;
+//   const step2 = `e^{${u}}((${a}x${b >= 0 ? "+" : ""}${b}) ${operator} (${c}x${
+//     d >= 0 ? "+" : ""
+//   }${d}))`;
+//   return `${alignTex([
+//     ["", step1],
+//     ["=", step2],
+//   ])}
+// On a mis en facteur $e^{${u}}$ qui est le terme exponentiel commun.`;
+// };
+const getKeys = () => {
+    return ["epower", "x"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        if (!isMultiplyNode(parsed))
+            return false;
+        const simp = parsed.simplify({
+            forbidFactorize: true,
+            towardsDistribute: true,
+        });
+        const answerSimp = getAnswerNode(identifiers).simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        });
+        // const simp = parsed.simplify({});
+        return simp.toTex() === answerSimp.toTex();
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getExpFactorizationQuestion = () => {
+    const a = randint(-5, 5, [0]);
+    const b = randint(-5, 5);
+    const c = b === 0 ? 1 : randint(-5, 5, [0]);
+    const d = randint(-5, 5, [0]);
+    const e = randint(-5, 5, b === 0 ? [0] : []);
+    const f = e === 0 ? 1 : randint(-5, 5);
+    // Generate random function for exponent
+    const uA = randint(-9, 10, [0]);
+    const identifiers = {
+        a,
+        b,
+        c,
+        d,
+        e,
+        f,
+        uA,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const expFactorization = {
+    id: "expFactorization",
+    connector: "=",
+    label: "Factoriser une expression avec des exponentielles",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpFactorizationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    // getHint,
+    // getCorrection,
+    getAnswer,
+    // hasHintAndCorrection: true,
+};

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

@@ -1,3 +1,4 @@
 export * from "./expEquation.js";
 export * from "./expSimplifiying.js";
+export * from "./expFactorization.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponential/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponential/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC"}

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

@@ -1,2 +1,3 @@
 export * from "./expEquation.js";
 export * from "./expSimplifiying.js";
+export * from "./expFactorization.js";

package/lib/exercises/math/geometry/euclidian/index.js

@@ -1 +1,2 @@
 export {};
+// export * from "./pythagoreOrThales.js";

package/lib/exercises/math/geometry/euclidian/pythagoreOrThales.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pythagoreOrThales.d.ts.map

package/lib/exercises/math/geometry/euclidian/pythagoreOrThales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pythagoreOrThales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pythagoreOrThales.ts"],"names":[],"mappings":""}