math-exercises 3.0.158 → 3.0.160

package/lib/exercises/math/geometry/circles/circleCanonicalEquationFromDevEquation.js

@@ -0,0 +1,174 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { CircleConstructor } from "../../../../math/geometry/circle.js";
+import { Point, PointConstructor } from "../../../../math/geometry/point.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { equal } from "../../../../tree/nodes/equations/equalNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.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 { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { randomInt } from "crypto";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const fakeCenter = PointConstructor.random("C");
+        const fakeRadius = randomInt(1, 10);
+        tryToAddWrongProp(propositions, CircleConstructor.cartesianEquation(fakeCenter, fakeRadius).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const { aIds, bIds, cIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const c = reifyAlgebraic(cIds);
+    const abscisse = frac(a, -2).simplify();
+    const ordonne = frac(b, -2).simplify();
+    const radiusSquared = substract(add(square(abscisse), square(ordonne)), c).simplify();
+    return equal(add(square(substract("x", abscisse).simplify()), square(substract("y", ordonne).simplify())), radiusSquared.simplify());
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { aIds, bIds, cIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const c = reifyAlgebraic(cIds);
+    return `Soit $\\mathcal{C}$ le cercle dont une équation cartésienne sous forme développée est : 
+  
+$$
+${add(add(square("x"), multiply(a, "x")), add(add(square("y"), multiply(b, "y")), c))
+        .simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    })
+        .toTex()} = 0
+$$
+
+Donner l'équation cartésienne de $\\mathcal{C}$ sous forme canonique.`;
+};
+const getHint = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const aIsPos = a.evaluate() > 0;
+    const bIsPos = b.evaluate() > 0;
+    return `Réécrit l'équation en faisant apparaître des identités remarquables. 
+  
+Pour cela, tu peux compléter les égalités suivantes : 
+
+$$
+${add(square("x"), multiply(a, "x")).toTex()} = ${square((aIsPos ? add : substract)("x", "\\ldots")).toTex()} - \\ldots
+$$
+
+et 
+
+$$
+${add(square("y"), multiply(b, "y")).toTex()} = ${square((bIsPos ? add : substract)("y", "\\ldots")).toTex()} - \\ldots
+$$
+`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, bIds, cIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const c = reifyAlgebraic(cIds);
+    const abscisse = frac(a, -2).simplify();
+    const ordonne = frac(b, -2).simplify();
+    const firstId = substract(square(substract("x", abscisse).simplify()), square(abscisse).simplify());
+    const secondId = substract(square(substract("y", ordonne).simplify()), square(ordonne).simplify());
+    return `On réécrit l'équation en faisant apparaître des identités remarquables. Pour cela, on remarque que : 
+  
+$$
+${add(square("x"), multiply(a, "x")).toTex()} = ${firstId.toTex()}
+$$
+
+et :
+  
+$$
+${add(square("y"), multiply(b, "y")).toTex()} = ${secondId.toTex()}
+$$
+
+L'équation peut donc se réécrire : 
+
+$$
+${add(add(firstId, secondId), c).toTex()} = 0
+$$
+
+La forme canonique est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getKeys = () => {
+    return ["x", "y", "equal"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const split = ans.split("=");
+        if (split.length !== 2)
+            return false;
+        const left = parseAlgebraic(split[0]);
+        const right = parseAlgebraic(split[1]);
+        const studentEq = substract(left, right).simplify();
+        const eqNode = getAnswerNode(identifiers);
+        const ansNode = substract(eqNode.leftChild, eqNode.rightChild).simplify();
+        return studentEq.toTex() === ansNode.toTex();
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCircleCanonicalEquationFromDevEquationQuestion = () => {
+    const radius = randint(1, 10).toTree();
+    const centerx = randint(-9, 10, [0]);
+    const centery = randint(-9, 10, [0]);
+    const center = new Point("C", centerx, centery);
+    const identifiers = {
+        aIds: multiply(-2, center.x).simplify().toIdentifiers(),
+        bIds: multiply(-2, center.y).simplify().toIdentifiers(),
+        cIds: substract(add(square(center.x), square(center.y)), square(radius))
+            .simplify()
+            .toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const circleCanonicalEquationFromDevEquation = {
+    id: "circleCanonicalEquationFromDevEquation",
+    connector: "\\iff",
+    label: "Donner l'équation cartésienne canonique d'un cercle à partir d'une équation développée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCircleCanonicalEquationFromDevEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/circles/circleCenterAndRadiusFromEquation.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { EqualNodeIdentifiers } from "../../../../tree/nodes/equations/equalNode.js";
+type Identifiers = {
+    isAskingRadius: boolean;
+    equationIds: EqualNodeIdentifiers;
+};
+type Options = {
+    askedParameter: string;
+};
+export declare const circleCenterAndRadiusFromEquation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=circleCenterAndRadiusFromEquation.d.ts.map

package/lib/exercises/math/geometry/circles/circleCenterAndRadiusFromEquation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circleCenterAndRadiusFromEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/circles/circleCenterAndRadiusFromEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAEL,oBAAoB,EACrB,MAAM,yCAAyC,CAAC;AAWjD,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,WAAW,EAAE,oBAAoB,CAAC;CACnC,CAAC;AAqJF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAWF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwB1E,CAAC"}

package/lib/exercises/math/geometry/circles/circleCenterAndRadiusFromEquation.js

@@ -0,0 +1,161 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, GeneratorOptionType, GeneratorOptionTarget, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { pointVEA } from "../../../../exercises/vea/pointVEA.js";
+import { sqrtVEA } from "../../../../exercises/vea/sqrtVEA.js";
+import { CircleConstructor } from "../../../../math/geometry/circle.js";
+import { Point, PointConstructor } from "../../../../math/geometry/point.js";
+import { SquareRootConstructor } from "../../../../math/numbers/reals/real.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { reifyAlgebraic } from "../../../../tree/nodes/nodeConstructor.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, isAskingRadius }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        if (isAskingRadius)
+            tryToAddWrongProp(propositions, coinFlip()
+                ? randint(1, 10) + ""
+                : SquareRootConstructor.randomIrreductible(20).toTex());
+        else
+            tryToAddWrongProp(propositions, PointConstructor.random("A").toCoords());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { equationIds, isAskingRadius } = identifiers;
+    const equation = reifyAlgebraic(equationIds);
+    console.log(equation.toTex());
+    if (isAskingRadius)
+        return sqrt(equation.rightChild).simplify().toTex();
+    const left = equation.leftChild;
+    const xNode = left.leftChild;
+    const abscisse = opposite(xNode.leftChild.toDetailedEvaluation({ x: (0).toTree() })).simplify();
+    const yNode = left.rightChild;
+    const ordonnee = opposite(yNode.leftChild.toDetailedEvaluation({ y: (0).toTree() })).simplify();
+    return new Point("O", abscisse, ordonnee).toCoords();
+};
+const getInstruction = (identifiers) => {
+    const { equationIds, isAskingRadius } = identifiers;
+    const equation = reifyAlgebraic(equationIds);
+    return `Soit $\\mathcal{C}$ le cercle dont une équation cartésienne est : 
+  
+$$
+${equation.toTex()}
+$$
+
+${isAskingRadius
+        ? "Quel est le rayon de $\\mathcal{C}$ ?"
+        : "Quelles sont les coordonnées du centre de $\\mathcal{C}$ ?"}`;
+};
+const getHint = () => {
+    return `Si $A(x_A;y_A)$ est le centre d'un cercle $\\mathcal{C}$ de rayon $R$, alors une équation cartésienne de $\\mathcal{C}$ est : 
+  
+$$
+(x-x_A)^2+(y-y_A)^2 = R^2
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { isAskingRadius, equationIds } = identifiers;
+    const radius = getAnswer({ equationIds, isAskingRadius: true });
+    const coords = getAnswer({ equationIds, isAskingRadius: false });
+    const coordsTrimed = coords
+        .replaceAll("\\left", "")
+        .replaceAll("\\right", "")
+        .replaceAll("(", "")
+        .replaceAll(")", "");
+    const abscisse = coordsTrimed.split(";")[0].unfrenchify();
+    const ordonnee = coordsTrimed.split(";")[1].unfrenchify();
+    return `Si $A(x_A;y_A)$ est le centre d'un cercle $\\mathcal{C}$ de rayon $R$, alors une équation cartésienne de $R$ est : 
+  
+$$
+(x-x_A)^2+(y-y_A)^2 = R^2
+$$
+
+Ici, on peut donc réécrire l'équation pour faire apparaître les coordonnées du centre et le rayon : 
+
+$$
+(${substract("x", abscisse).toTex()})^2 + (${substract("y", ordonnee).toTex()})^2 = ${square(radius).toTex()}
+$$
+
+${isAskingRadius
+        ? `Le rayon de $\\mathcal{C}$ est donc $${radius}$.`
+        : `Les coordonnées du centre de $\\mathcal{C}$ sont donc $${coords}$.`}`;
+};
+const getKeys = () => {
+    return ["semicolon"];
+};
+const isAnswerValid = (ans, { answer, isAskingRadius }) => {
+    try {
+        if (isAskingRadius)
+            return sqrtVEA(ans, answer);
+        else {
+            return pointVEA(ans, answer);
+        }
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCircleCenterAndRadiusFromEquationQuestion = (opts) => {
+    const isAskingRadius = opts?.askedParameter === "Rayon"
+        ? true
+        : opts?.askedParameter === "Coordonnées du centre"
+            ? false
+            : coinFlip();
+    const center = PointConstructor.random("O");
+    const radius = coinFlip()
+        ? randint(1, 10).toTree()
+        : SquareRootConstructor.randomIrreductible(20).toTree();
+    const eq = CircleConstructor.cartesianEquation(center, radius);
+    console.log("rad ", radius.toTex(), "eq ", eq.toTex());
+    const identifiers = {
+        isAskingRadius,
+        equationIds: eq.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+const options = [
+    {
+        id: "askedParameter",
+        label: "Paramètre demandé",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["Rayon", "Coordonnées du centre", "L'un ou l'autre aléatoirement"],
+        defaultValue: "L'un ou l'autre aléatoirement",
+    },
+];
+export const circleCenterAndRadiusFromEquation = {
+    id: "circleCenterAndRadiusFromEquation",
+    connector: "=",
+    label: "Déterminer le centre ou le rayon d'un cercle dans son équation canonique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCircleCenterAndRadiusFromEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    options,
+};

package/lib/exercises/math/geometry/circles/circleEquationFromDiameter.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type Identifiers = {
+    AIds: PointIdentifiers;
+    BIds: PointIdentifiers;
+};
+export declare const circleEquationFromDiameter: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=circleEquationFromDiameter.d.ts.map

package/lib/exercises/math/geometry/circles/circleEquationFromDiameter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circleEquationFromDiameter.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/circles/circleEquationFromDiameter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAStC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,gBAAgB,CAAC;CACxB,CAAC;AA+JF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAmB5D,CAAC"}

package/lib/exercises/math/geometry/circles/circleEquationFromDiameter.js

@@ -0,0 +1,145 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { PointConstructor, } from "../../../../math/geometry/point.js";
+import { Vector } from "../../../../math/geometry/vector.js";
+import { equal } from "../../../../tree/nodes/equations/equalNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const [A, B] = PointConstructor.randomDifferent(2, {});
+        tryToAddWrongProp(propositions, getAnswer({
+            AIds: A.toIdentifiers(),
+            BIds: B.toIdentifiers(),
+        }));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    // const { AIds, BIds } = identifiers;
+    // const A = PointConstructor.fromIdentifiers(AIds);
+    // const B = PointConstructor.fromIdentifiers(BIds);
+    // const center = A.midpoint(B).simplify();
+    // const radius = frac(A.distanceToNode(B), 2).simplify();
+    // return CircleConstructor.cartesianEquation(center, radius);
+    const { AIds, BIds } = identifiers;
+    const A = PointConstructor.fromIdentifiers(AIds);
+    const B = PointConstructor.fromIdentifiers(BIds);
+    const AM = new Vector("AM", substract("x", A.x), substract("y", A.y)).simplify();
+    const BM = new Vector("BM", substract("x", B.x), substract("y", B.y)).simplify();
+    return equal(AM.scalarProduct(BM)
+        .simplify({ forbidFactorize: true, towardsDistribute: true })
+        .toTex(), 0);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { AIds, BIds } = identifiers;
+    const A = PointConstructor.fromIdentifiers(AIds);
+    const B = PointConstructor.fromIdentifiers(BIds);
+    return `Soit $\\mathcal{C}$ le cercle de diamètre $[AB]$, avec $${A.toTexWithCoords()}$ et $${B.toTexWithCoords()}$.
+  
+Donner une équation cartésienne du cercle $\\mathcal{C}$.`;
+};
+const getHint = () => {
+    return `Si $[AB]$ est le diamètre d'un cercle $\\mathcal{C}$, alors tout point de $C$ est tel que $ABC$ est un triangle rectangle en $C$. 
+  
+Cela signifie donc qu'un point $C(x;y)$ est sur le cercle $\\mathcal{C}$ si et seulement si les vecteurs $\\overrightarrow{AC}$ et $\\overrightarrow{BC}$ sont orthogonaux.`;
+};
+const getCorrection = (identifiers) => {
+    const { AIds, BIds } = identifiers;
+    const A = PointConstructor.fromIdentifiers(AIds);
+    const B = PointConstructor.fromIdentifiers(BIds);
+    const AM = new Vector("AM", substract("x", A.x), substract("y", A.y)).simplify();
+    const BM = new Vector("BM", substract("x", B.x), substract("y", B.y)).simplify();
+    // const center = A.midpoint(B).simplify();
+    // const radius = frac(A.distanceToNode(B), 2).simplify();
+    // const canoEq = CircleConstructor.cartesianEquation(center, radius).toTex();
+    return `On considère un point $M(x;y)$.
+  
+Le point $M$ appartient à $\\mathcal{C}$ si seulement si le triangle $ABM$ est rectangle en $M$, c'est à dire si $\\overrightarrow{AM}$ et $\\overrightarrow{BM}$ sont orthogonaux.
+
+Donc le point $M$ appartient à $\\mathcal{C}$ si et seulement si : 
+
+${alignTex([
+        ["", "\\overrightarrow{AM}\\cdot \\overrightarrow{BM}=0"],
+        ["\\iff", `${AM.scalarProduct(BM).toTex()} = 0`],
+        [
+            "\\iff",
+            `${AM.scalarProduct(BM)
+                .simplify({ forbidFactorize: true, towardsDistribute: true })
+                .toTex()} = 0`,
+        ],
+    ])}
+
+Une équation cartésienne du cercle $\\mathcal{C}$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = () => {
+    return ["x", "y", "equal"];
+};
+const isAnswerValid = (ans, { answer: _answer, ...identifiers }) => {
+    try {
+        const split = ans.split("=");
+        if (split.length !== 2)
+            return false;
+        const left = parseAlgebraic(split[0]);
+        const right = parseAlgebraic(split[1]);
+        const studentEq = substract(left, right).simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        });
+        const ansNodeDev = getAnswerNode(identifiers).leftChild;
+        return studentEq.toTex() === ansNodeDev.toTex();
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCircleEquationFromDiameterQuestion = () => {
+    const A = PointConstructor.random("A");
+    const B = doWhile(() => PointConstructor.random("B"), (p) => p.equals(A));
+    const identifiers = {
+        AIds: A.toIdentifiers(),
+        BIds: B.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const circleEquationFromDiameter = {
+    id: "circleEquationFromDiameter",
+    connector: "\\iff",
+    label: "Déterminer une équation cartésienne d'un cercle en connaissant son diamètre",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCircleEquationFromDiameterQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/circles/circleEquationFromPointAndRadius.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    centerIds: PointIdentifiers;
+    radiusIds: NodeIdentifiers;
+};
+type Options = {
+    equationType: string;
+};
+export declare const circleEquationFromPointAndRadius: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=circleEquationFromPointAndRadius.d.ts.map

package/lib/exercises/math/geometry/circles/circleEquationFromPointAndRadius.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circleEquationFromPointAndRadius.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/circles/circleEquationFromPointAndRadius.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAItC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,SAAS,EAAE,eAAe,CAAC;CAC5B,CAAC;AAwMF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAYF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwBzE,CAAC"}