math-exercises 3.0.158 → 3.0.160

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

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

@@ -0,0 +1,191 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } 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 { Point, PointConstructor } from "../../../../math/geometry/point.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { equal } from "../../../../tree/nodes/equations/equalNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.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 { 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, randint(1, 10).frenchify());
+        else
+            tryToAddWrongProp(propositions, PointConstructor.random("A").toCoords());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIds, bIds, cIds, isAskingRadius } = 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();
+    if (isAskingRadius) {
+        return sqrt(radiusSquared).simplify().toTex();
+    }
+    else {
+        return new Point("O", abscisse, ordonne).toCoords();
+    }
+};
+const getInstruction = (identifiers) => {
+    const { aIds, bIds, cIds, isAskingRadius } = 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
+$$
+
+${isAskingRadius
+        ? "Quel est le rayon de $\\mathcal{C}$ ?"
+        : "Quelles sont les coordonnées du centre de $\\mathcal{C}$ ?"}`;
+};
+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 `Tout cercle $\\mathcal{C}$ de centre $A(x_A;y_A)$ et de rayon $R$ admet une équation de la forme :
+  
+$$
+(x-x_A)^2+(y-y_A)^2 = R^2
+$$
+  
+Pour se ramener à cette équation, fait apparaître des identités remarquables dans l'équation de l'énoncé. 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, isAskingRadius } = 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();
+    const firstId = substract(square(substract("x", abscisse).simplify()), square(abscisse).simplify());
+    const secondId = substract(square(substract("y", ordonne).simplify()), square(ordonne).simplify());
+    return `Tout cercle $\\mathcal{C}$ de centre $A(x_A;y_A)$ et de rayon $R$ admet une équation de la forme :
+  
+$$
+(x-x_A)^2+(y-y_A)^2 = R^2
+$$  
+  
+On réécrit donc 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 : 
+
+$$
+${equal(add(square(substract("x", abscisse).simplify()), square(substract("y", ordonne).simplify())), radiusSquared.simplify()).toTex()}
+$$
+
+${isAskingRadius
+        ? `Le rayon de $\\mathcal{C}$ est donc $${getAnswer(identifiers)}$.`
+        : `Les coordonnées du centre de $\\mathcal{C}$ sont donc $${getAnswer(identifiers)}$.`}
+`;
+};
+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 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(),
+        isAskingRadius: coinFlip(),
+    };
+    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 circleRadiusOrCenterFromDevEquation = {
+    id: "circleRadiusOrCenterFromDevEquation",
+    connector: "\\iff",
+    label: "Déterminer le rayon ou le centre d'un cercle à partir d'un équation cartésienne 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/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./isPointOnCircleFromCartesianEquation.js";
+export * from "./circleEquationFromPointAndRadius.js";
+export * from "./circleCenterAndRadiusFromEquation.js";
+export * from "./circleCanonicalEquationFromDevEquation.js";
+export * from "./circleEquationFromDiameter.js";
+export * from "./circleRadiusOrCenterFromDevEquation.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/circles/index.ts"],"names":[],"mappings":"AAAA,cAAc,2CAA2C,CAAC;AAC1D,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AACvD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,iCAAiC,CAAC;AAChD,cAAc,0CAA0C,CAAC"}

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

@@ -0,0 +1,6 @@
+export * from "./isPointOnCircleFromCartesianEquation.js";
+export * from "./circleEquationFromPointAndRadius.js";
+export * from "./circleCenterAndRadiusFromEquation.js";
+export * from "./circleCanonicalEquationFromDevEquation.js";
+export * from "./circleEquationFromDiameter.js";
+export * from "./circleRadiusOrCenterFromDevEquation.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"isPointOnCircleFromCartesianEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/circles/isPointOnCircleFromCartesianEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,SAAS,EAAE,eAAe,CAAC;IAC3B,SAAS,EAAE,gBAAgB,CAAC;CAC7B,CAAC;AA8HF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CAqBtE,CAAC"}

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

@@ -0,0 +1,131 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { 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 { PiNode } from "../../../../tree/nodes/numbers/piNode.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 { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getEquation = (identifiers) => {
+    const { centreIds, radiusIds } = identifiers;
+    const radius = reifyAlgebraic(radiusIds);
+    const centre = PointConstructor.fromIdentifiers(centreIds);
+    return equal(add(square(substract("x", centre.x).simplify()), square(substract("y", centre.y).simplify())), square(radius).simplify());
+};
+const getAnswer = (identifiers) => {
+    const { centreIds, pointIds, radiusIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const radius = reifyAlgebraic(radiusIds);
+    const centre = PointConstructor.fromIdentifiers(centreIds);
+    return Math.abs(point.distanceTo(centre) - radius.evaluate()) < 0.001
+        ? "Oui"
+        : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { pointIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    return `On considère le cercle $\\mathcal{C}$ d'équation : 
+  
+$$
+${getEquation(identifiers).toTex()}
+$$
+
+Le point $${point.toTexWithCoords()}$ appartient-il au cercle $\\mathcal{C}$ ?`;
+};
+const getHint = () => {
+    return `Il suffit de remplacer $x$ et $y$ par les coordonnées de $A$ dans l'équation du cercle.`;
+};
+const getCorrection = (identifiers) => {
+    const { centreIds, pointIds } = identifiers;
+    const centre = PointConstructor.fromIdentifiers(centreIds);
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const leftEq = add(square(substract("x", centre.x).simplify()), square(substract("y", centre.y).simplify()));
+    const leftEqDetailed = leftEq.toDetailedEvaluation({
+        x: point.x,
+        y: point.y,
+    });
+    const isOnCircle = getAnswer(identifiers) === "Oui";
+    return `On remplace $x$ et $y$ par les coordonnées de $A$ dans l'équation du cercle : 
+  
+${alignTex([
+        ["", leftEqDetailed.toTex()],
+        [
+            "=",
+            add(square(substract(point.x, centre.x).simplify()), square(substract(point.y, centre.y).simplify())).toTex(),
+        ],
+        ["=", leftEqDetailed.simplify().toTex()],
+    ])}
+
+${isOnCircle
+        ? `Puisque l'égalité est bien vérifie, le point $A$ appartient bien au cercle.`
+        : `Puisque l'égalité n'est pas vérifiée, le point $A$ n'appartient pas au cercle.`}
+`;
+};
+const getIsPointOnCircleFromCartesianEquationQuestion = () => {
+    const centre = PointConstructor.random("O");
+    const radius = randint(1, 10).toTree();
+    const isOnCircle = coinFlip();
+    let point;
+    if (isOnCircle) {
+        // point = PointConstructor.random("A");
+        const angle = frac(PiNode, 2);
+        const index = randint(0, 4);
+        point = centre
+            .translate(radius, 0)
+            .centralRotate(multiply(index, angle).simplify(), centre, "A");
+    }
+    else {
+        do {
+            point = PointConstructor.random("A");
+        } while (Math.abs(point.distanceTo(centre) - radius.evaluate()) < 0.001);
+    }
+    const identifiers = {
+        centreIds: centre.toIdentifiers(),
+        radiusIds: radius.toIdentifiers(),
+        pointIds: point.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const isPointOnCircleFromCartesianEquation = {
+    id: "isPointOnCircleFromCartesianEquation",
+    connector: "=",
+    label: "Déterminer si un point appartient à un cercle d'équation donnée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsPointOnCircleFromCartesianEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -1 +1 @@
-{"version":3,"file":"pinSegmentFromRotation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pinSegmentFromRotation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAOtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAuK7C,KAAK,yBAAyB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,gBAAgB,CAAC;IACzB,cAAc,EAAE,eAAe,CAAC;CACjC,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,EAAE,yBAAyB,CAAC;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAsYF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}
+{"version":3,"file":"pinSegmentFromRotation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pinSegmentFromRotation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAOtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAuK7C,KAAK,yBAAyB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,gBAAgB,CAAC;IACzB,cAAc,EAAE,eAAe,CAAC;CACjC,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,EAAE,yBAAyB,CAAC;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAoYF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

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

@@ -246,7 +246,6 @@ const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
             }
             return acc;
         }, {});
-        console.log("pointsDict", pointsDict);
         return pointsDict;
     }
     function getStudentSegmentsDictFromStudentCommands(commands) {
@@ -261,7 +260,6 @@ const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
             }
             return acc;
         }, {});
-        console.log("segmentsDict", segmentsDict);
         return segmentsDict;
     }
     const isSegmentValid = () => {

package/lib/exercises/math/geometry/index.d.ts

@@ -15,4 +15,5 @@ export * from "./angles/index.js";
 export * from "./lines/index.js";
 export * from "./triangles/index.js";
 export * from "./optimisation/index.js";
+export * from "./circles/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mCAAmC,CAAC;AAClD,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mCAAmC,CAAC;AAClD,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC"}

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

@@ -15,3 +15,4 @@ export * from "./angles/index.js";
 export * from "./lines/index.js";
 export * from "./triangles/index.js";
 export * from "./optimisation/index.js";
+export * from "./circles/index.js";

package/lib/exercises/math/geometry/lines/cartesianEquationOfTriangleHeight.d.ts

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

package/lib/exercises/math/geometry/lines/cartesianEquationOfTriangleHeight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cartesianEquationOfTriangleHeight.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/cartesianEquationOfTriangleHeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAYtC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,gBAAgB,CAAC;CACxB,CAAC;AA6LF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAqBnE,CAAC"}