math-exercises 3.0.159 → 3.0.161

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"}

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

@@ -0,0 +1,181 @@
+import { addValidProp, shuffleProps, propWhile, GeneratorOptionTarget, GeneratorOptionType, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { PointConstructor, } from "../../../../math/geometry/point.js";
+import { SquareRootConstructor } from "../../../../math/numbers/reals/real.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 { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }, opts) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const radiusIds = randint(1, 10).toTree().toIdentifiers();
+        const centerIds = PointConstructor.random("O").toIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer({
+            centerIds,
+            radiusIds,
+        }, opts));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnnswerNode = (identifiers, opts) => {
+    const { centerIds, radiusIds } = identifiers;
+    const center = PointConstructor.fromIdentifiers(centerIds);
+    const radius = reifyAlgebraic(radiusIds);
+    const radiusSquared = square(radius).simplify();
+    const isDev = opts?.equationType === "Développée";
+    if (isDev) {
+        return equal(substract(add(square(substract("x", center.x).simplify()), square(substract("y", center.y).simplify())), radiusSquared).simplify({ towardsDistribute: true, forbidFactorize: true }), "0");
+    }
+    else {
+        return equal(add(square(substract("x", center.x).simplify()), square(substract("y", center.y).simplify())), square(radius).simplify());
+    }
+};
+const getAnswer = (identifiers, opts) => {
+    return getAnnswerNode(identifiers, opts).toTex();
+};
+const getInstruction = (identifiers, opts) => {
+    const { centerIds, radiusIds } = identifiers;
+    const center = PointConstructor.fromIdentifiers(centerIds);
+    const radius = reifyAlgebraic(radiusIds);
+    return `Le cercle $\\mathcal{C}$ a pour centre $${center.toTexWithCoords()}$ et pour rayon $${radius.toTex()}$.
+
+Donner une équation cartésienne du cercle $\\mathcal{C}$${opts?.equationType === "Développée" ? " **sous forme développée**" : ""}.`;
+};
+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 $R$ est : 
+  
+$$
+(x-x_A)^2+(y-y_A)^2 = R^2
+$$`;
+};
+const getCorrection = (identifiers, opts) => {
+    const { centerIds, radiusIds } = identifiers;
+    const center = PointConstructor.fromIdentifiers(centerIds);
+    const radius = reifyAlgebraic(radiusIds);
+    const radiusSquared = square(radius).simplify();
+    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, une équation cartésienne de $\\mathcal{C}$ est donc : 
+
+$$
+(${substract("x", center.x).simplify().toTex()})^2 + (${substract("y", center.y)
+        .simplify()
+        .toTex()})^2 = ${square(radius).simplify().toTex()}
+$$
+
+${opts?.equationType === "Développée"
+        ? `Il suffit alors de développer en utilisant des identités remarquables :
+
+$$
+${square(substract("x", center.x))
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        })
+            .toTex()} + ${square(substract("y", center.y))
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        })
+            .toTex()} = ${radiusSquared.toTex()}
+$$
+
+$$
+${substract(add(square(substract("x", center.x).simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        })), square(substract("y", center.y).simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        }))), radiusSquared)
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex()} = 0
+$$
+  `
+        : ``}`;
+};
+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 = getAnnswerNode(identifiers, {
+            equationType: "Développée",
+        }).leftChild;
+        return studentEq.toTex() === ansNodeDev.toTex();
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCircleEquationFromPointAndRadisuQuestion = (opts) => {
+    const center = PointConstructor.random("O");
+    const radius = coinFlip()
+        ? randint(1, 10).toTree()
+        : SquareRootConstructor.randomIrreductible(20).toTree();
+    const identifiers = {
+        centerIds: center.toIdentifiers(),
+        radiusIds: radius.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+const options = [
+    {
+        id: "equationType",
+        label: "Forme de l'équation attendue",
+        target: GeneratorOptionTarget.answer,
+        type: GeneratorOptionType.select,
+        values: ["Canonique", "Développée"],
+        defaultValue: "Canonique",
+    },
+];
+export const circleEquationFromPointAndRadius = {
+    id: "circleEquationFromPointAndRadius",
+    connector: "\\iff",
+    label: "Déterminer l'équation cartésienne d'un cercle en connaissant son centre et son rayon",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCircleEquationFromPointAndRadisuQuestion(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/circleRadiusOrCenterFromDevEquation.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aIds: NodeIdentifiers;
+    bIds: NodeIdentifiers;
+    cIds: NodeIdentifiers;
+    isAskingRadius: boolean;
+};
+export declare const circleRadiusOrCenterFromDevEquation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=circleRadiusOrCenterFromDevEquation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"circleRadiusOrCenterFromDevEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/circles/circleRadiusOrCenterFromDevEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AA0MF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,WAAW,CAsBrE,CAAC"}