math-exercises 3.0.158 → 3.0.160

package/lib/exercises/math/sequences/notation/identifyRankInSequenceTermsList.js

@@ -0,0 +1,114 @@
+import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const ansNb = answer.unfrenchify();
+    tryToAddWrongProp(propositions, (ansNb + 1).frenchify());
+    if (ansNb > 0)
+        tryToAddWrongProp(propositions, (ansNb - 1).frenchify());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, random([0, 1, 2, 3, 4, 5]).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { askedTerm, values, firstRank } = identifiers;
+    return (values.indexOf(askedTerm) + firstRank).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { askedTerm, firstRank, values } = identifiers;
+    return `Soit $u$ une suite de premier rang $${firstRank}$ et dont voici les premiers termes, dans l'ordre : 
+  
+$$
+${values.join("\\ ; \\ ")}
+$$
+
+Quel est le rang du terme $${askedTerm}$ ?`;
+};
+const getHint = () => {
+    return `Il suffit de compter à partir du premier rang de la suite.`;
+};
+const getCorrection = (identifiers) => {
+    const { firstRank, values } = identifiers;
+    return `Voici la notation pour chacun des termes : 
+
+${values
+        .map((e, i) => `$$
+u_${i + firstRank} = ${e}
+$$`)
+        .join("\n \n")}
+
+Le rang recherché est donc $${getAnswer(identifiers)}$.`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getIdentifySequenceTermInListQuestion = (opts) => {
+    const firstRank = opts?.firstRank === "$0$"
+        ? 0
+        : opts?.firstRank === "$1$"
+            ? 1
+            : randint(0, 2);
+    const values = randTupleInt(5, { from: -10, to: 10, allDifferent: true });
+    const askedTerm = random(values.slice(1));
+    const identifiers = {
+        firstRank,
+        values,
+        askedTerm,
+    };
+    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: "firstRank",
+        label: "Premier rang",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["$0$", "$1$", "Les deux aléatoirement"],
+        defaultValue: "Les deux aléatoirement",
+    },
+];
+export const identifyRankInSequenceTermsList = {
+    id: "identifyRankInSequenceTermsList",
+    connector: "=",
+    label: "Identifier le rang d'un terme dans les premiers termes d'une suite",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIdentifySequenceTermInListQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    options,
+};

package/lib/exercises/math/sequences/notation/identifySequenceTermInList.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    values: number[];
+    firstRank: number;
+    askedIndex: number;
+};
+type Options = {
+    firstRank: string;
+};
+export declare const identifySequenceTermInList: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=identifySequenceTermInList.d.ts.map

package/lib/exercises/math/sequences/notation/identifySequenceTermInList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifySequenceTermInList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/notation/identifySequenceTermInList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA+FF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAYF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBrE,CAAC"}

package/lib/exercises/math/sequences/notation/identifySequenceTermInList.js

@@ -0,0 +1,111 @@
+import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, values }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, random(values).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { askedIndex, values } = identifiers;
+    return values[askedIndex].frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { askedIndex, firstRank, values } = identifiers;
+    return `Soit $u$ une suite de premier rang $${firstRank}$ et dont voici les premiers termes, dans l'ordre : 
+  
+$$
+${values.join("\\ ; \\ ")}
+$$
+
+Quel est le terme de rang $${askedIndex + firstRank}$ ?`;
+};
+const getHint = () => {
+    return `Il suffit de compter à partir du premier rang de la suite.`;
+};
+const getCorrection = (identifiers) => {
+    const { askedIndex, firstRank, values } = identifiers;
+    return `Voici la notation pour chacun des termes : 
+
+${values
+        .map((e, i) => `$$
+u_${i + firstRank} = ${e}
+$$`)
+        .join("\n \n")}
+
+Le terme de rang $${askedIndex + firstRank}$ est donc $${values[askedIndex + firstRank]}$.
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getIdentifySequenceTermInListQuestion = (opts) => {
+    const firstRank = opts?.firstRank === "$0$"
+        ? 0
+        : opts?.firstRank === "$1$"
+            ? 1
+            : randint(0, 2);
+    const values = randTupleInt(5, { from: -10, to: 10, allDifferent: true });
+    const askedIndex = randint(1, 5);
+    const identifiers = {
+        firstRank,
+        values,
+        askedIndex,
+    };
+    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: "firstRank",
+        label: "Premier rang",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["$0$", "$1$", "Les deux aléatoirement"],
+        defaultValue: "Les deux aléatoirement",
+    },
+];
+export const identifySequenceTermInList = {
+    id: "identifySequenceTermInList",
+    connector: "=",
+    label: "Identifier le terme de rang $k$ dans les premiers termes d'une suite",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIdentifySequenceTermInListQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    options,
+};

package/lib/exercises/math/sequences/notation/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./identifySequenceTermInList.js";
+export * from "./identifyRankInSequenceTermsList.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/notation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/notation/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,sCAAsC,CAAC"}

package/lib/exercises/math/sequences/notation/index.js

@@ -0,0 +1,2 @@
+export * from "./identifySequenceTermInList.js";
+export * from "./identifyRankInSequenceTermsList.js";

package/lib/exercises/math/spaceGeometry/basis/findSpacePointOnRectangularPrism.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findSpacePointOnRectangularPrism.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/findSpacePointOnRectangularPrism.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAkB3C,KAAK,WAAW,GAAG;IAEjB,sBAAsB,EAAE,qBAAqB,CAAC;IAC9C,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,qBAAqB,EAAE,qBAAqB,EAAE,CAAC;IAE/C,oBAAoB,EAAE,qBAAqB,EAAE,CAAC;IAC9C,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAqgBF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAiBlE,CAAC"}
+{"version":3,"file":"findSpacePointOnRectangularPrism.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/findSpacePointOnRectangularPrism.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAkB3C,KAAK,WAAW,GAAG;IAEjB,sBAAsB,EAAE,qBAAqB,CAAC;IAC9C,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,qBAAqB,EAAE,qBAAqB,EAAE,CAAC;IAE/C,oBAAoB,EAAE,qBAAqB,EAAE,CAAC;IAC9C,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAogBF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAiBlE,CAAC"}

package/lib/exercises/math/spaceGeometry/basis/findSpacePointOnRectangularPrism.js

@@ -260,7 +260,6 @@ const getGGBOptions = (identifiers) => {
     });
 };
 const getPropositions = (n, { answer, ...identifiers }) => {
-    console.log("answer", answer);
     const propositions = [];
     addValidProp(propositions, answer);
     const { arrPoolSpacePointIds } = identifiers;

package/lib/exercises/math/spaceGeometry/sphere/sphereLatLonReading.2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sphereLatLonReading.2d.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sphere/sphereLatLonReading.2d.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAuFtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE;QACT,MAAM,EAAE,gBAAgB,CAAC;QACzB,IAAI,EAAE,gBAAgB,CAAC;KACxB,CAAC;IAEF,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AA+KF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}
+{"version":3,"file":"sphereLatLonReading.2d.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sphere/sphereLatLonReading.2d.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAuFtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE;QACT,MAAM,EAAE,gBAAgB,CAAC;QACzB,IAAI,EAAE,gBAAgB,CAAC;KACxB,CAAC;IAEF,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AA6KF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}

package/lib/exercises/math/spaceGeometry/sphere/sphereLatLonReading.2d.js

@@ -152,8 +152,6 @@ const getKeys = () => {
     return ["degree", "N", "O", "S", "E"];
 };
 const isAnswerValid = (ans, { answer }) => {
-    console.log("ans", ans);
-    console.log("answer", answer);
     const ansRefined = ans.replace("^{\\circ}", "°");
     return ansRefined === answer;
 };

package/lib/exercises/vea/cartesianLineVEA.d.ts

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

package/lib/exercises/vea/cartesianLineVEA.d.ts.map

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

package/lib/exercises/vea/cartesianLineVEA.js

@@ -0,0 +1 @@
+export {};

package/lib/exercises/vea/pointVEA.d.ts

@@ -0,0 +1,2 @@
+export declare const pointVEA: (studentAns: string, answer: string) => boolean;
+//# sourceMappingURL=pointVEA.d.ts.map

package/lib/exercises/vea/pointVEA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/pointVEA.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ,GAAI,YAAY,MAAM,EAAE,QAAQ,MAAM,YAI1D,CAAC"}

package/lib/exercises/vea/pointVEA.js

@@ -0,0 +1,7 @@
+import { pointParser } from "../../tree/parsers/pointParser.js";
+export const pointVEA = (studentAns, answer) => {
+    const parsed = pointParser(studentAns);
+    if (!parsed)
+        return false;
+    return parsed.simplify().toCoords() === answer;
+};

package/lib/index.d.ts

@@ -584,6 +584,24 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
+}, {
+    solutionFormat: string;
+}> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+}, {
+    solutionFormat: string;
+}> | Exercise<{
+    coeffsF: number[];
+    coeffsG: number[];
+}, {
+    solutionFormat: string;
+    functionTypeF: string;
+    functionTypeG: string;
+}> | Exercise<{
+    a: number;
+    b: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
@@ -683,6 +701,14 @@ declare const mathExercises: (Exercise<{
     k: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     inequationSymbol: import("./math/inequations/inequation.js").InegalitySymbols;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    coeffsF: number[];
+    coeffsG: number[];
+    ineqType: import("./math/inequations/inequation.js").InegalitySymbols;
+}, {
+    inequationSolutionFormat: string;
+    functionTypeF: string;
+    functionTypeG: string;
+}> | Exercise<{
     rand: boolean;
     poly1: number[];
     poly2: number[];
@@ -890,6 +916,11 @@ declare const mathExercises: (Exercise<{
     affine2Coeffs: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     coeffs: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
@@ -1006,6 +1037,8 @@ declare const mathExercises: (Exercise<{
     b: number;
     c: number;
     d: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    splinePoints: number[][];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     coeffs: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -1333,6 +1366,12 @@ declare const mathExercises: (Exercise<{
     roots: number[];
     a: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    x1Ids: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    x2Ids: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {
+    rootsNb: string;
+}> | Exercise<{
     trinomIdentifiers: import("./tree/nodes/polynomials/trinomNode.js").TrinomNodeIdentifiers;
     firstRootIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -1397,6 +1436,12 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pointAIds: import("./math/geometry/point.js").PointIdentifiers;
+    pointBIds: import("./math/geometry/point.js").PointIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    summitIds: import("./math/geometry/point.js").PointIdentifiers;
+    pointIds: import("./math/geometry/point.js").PointIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     type: number;
     points: number[][];
@@ -1420,6 +1465,49 @@ declare const mathExercises: (Exercise<{
     e: number;
     f: number;
     uA: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    exp1Rounded: number;
+    precision: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nodeIdsA: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsK: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    expARounded: number;
+    precision: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nodeIdsA: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsB: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsAOpB: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    expARounded: number;
+    expBRounded: number;
+    precision: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nodeIdsA: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsB: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsAOpB: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    rand: number;
+}, {
+    isUseExpNotation: boolean;
+}> | Exercise<{
+    nodeIdsF: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsT: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    x: number;
+    s: number;
+    coordsFrame: number[];
+    rand: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nodeIdsA: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsH: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsAOpH: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    expARounded: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    isExpPrime: boolean;
+    coordsFrame: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    isExpPrime: boolean;
+    coordsFrame: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     k: number;
@@ -1608,6 +1696,16 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     a: number;
     b: number;
+    intervalAskedIndex: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    intervalAskedIndex: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    b: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     twoSided: boolean;
     a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
@@ -1747,6 +1845,18 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     pointIdentifiers: import("./math/geometry/point.js").PointIdentifiers;
     pointBIdentifiers: import("./math/geometry/point.js").PointIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    cIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pointIds: import("./math/geometry/point.js").PointIdentifiers;
+    vecIds: import("./math/geometry/vector.js").VectorIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pointIds: import("./math/geometry/point.js").PointIdentifiers;
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    cIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     coin: boolean;
     radius: number;
@@ -2230,7 +2340,9 @@ declare const mathExercises: (Exercise<{
     b: number;
     c: number;
     toReduced: boolean;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    direction: string;
+}> | Exercise<{
     a: number;
     b: number;
     c: number;
@@ -2288,6 +2400,10 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    AIds: import("./math/geometry/point.js").PointIdentifiers;
+    BIds: import("./math/geometry/point.js").PointIdentifiers;
+    CIds: import("./math/geometry/point.js").PointIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
     type: number;
@@ -2321,6 +2437,32 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     shape: number;
     side: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pointIds: import("./math/geometry/point.js").PointIdentifiers;
+    radiusIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    centreIds: import("./math/geometry/point.js").PointIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    centerIds: import("./math/geometry/point.js").PointIdentifiers;
+    radiusIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {
+    equationType: string;
+}> | Exercise<{
+    isAskingRadius: boolean;
+    equationIds: import("./tree/nodes/equations/equalNode.js").EqualNodeIdentifiers;
+}, {
+    askedParameter: string;
+}> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    cIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    AIds: import("./math/geometry/point.js").PointIdentifiers;
+    BIds: import("./math/geometry/point.js").PointIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    cIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    isAskingRadius: boolean;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     coeffs: number[];
     to: "+\\infty" | "-\\infty";
@@ -2754,6 +2896,10 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     xValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     yValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    valuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    probasIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    avgIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     pA: number;
     pB: number;
@@ -3026,6 +3172,23 @@ declare const mathExercises: (Exercise<{
     points: number[][];
     isArithmetic: boolean;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    firstRank: number;
+    values: number[];
+}, {
+    firstRank: string;
+}> | Exercise<{
+    values: number[];
+    firstRank: number;
+    askedIndex: number;
+}, {
+    firstRank: string;
+}> | Exercise<{
+    values: number[];
+    firstRank: number;
+    askedTerm: number;
+}, {
+    firstRank: string;
+}> | Exercise<{
     intervalIdentifiers: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     int1Identifiers: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/math/geometry/circle.d.ts

@@ -1,10 +1,16 @@
 import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps.js";
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
 import { Point } from "./point.js";
+export declare abstract class CircleConstructor {
+    static fromCenterAndRadius(center: Point, radius: AlgebraicNode | number, name?: string): Circle;
+    static cartesianEquation(center: Point, radius: AlgebraicNode | number): import("../../tree/nodes/equations/equalNode.js").EqualNode;
+}
 export declare class Circle {
     center: Point;
     point: Point;
     name: string;
     constructor(center: Point, point: Point, name?: string);
+    toCartesianEquation(): import("../../tree/nodes/equations/equalNode.js").EqualNode;
     toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, }?: ToGGBCommandsProps): string[];
 }
 //# sourceMappingURL=circle.d.ts.map

package/lib/math/geometry/circle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"circle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/circle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,qBAAa,MAAM;IACjB,MAAM,EAAE,KAAK,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;gBACD,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAMtD,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GACD,kBAAuB;CAoC1B"}
+{"version":3,"file":"circle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/circle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,mBAAmB,CACxB,MAAM,EAAE,KAAK,EACb,MAAM,EAAE,aAAa,GAAG,MAAM,EAC9B,IAAI,CAAC,EAAE,MAAM;IAIf,MAAM,CAAC,iBAAiB,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,GAAG,MAAM;CASvE;AACD,qBAAa,MAAM;IACjB,MAAM,EAAE,KAAK,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;gBACD,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAMtD,mBAAmB;IAWnB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GACD,kBAAuB;CAoC1B"}

package/lib/math/geometry/circle.js

@@ -1,3 +1,15 @@
+import { equal } from "../../tree/nodes/equations/equalNode.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";
+export class CircleConstructor {
+    static fromCenterAndRadius(center, radius, name) {
+        return new Circle(center, center.translate(radius, 0), name);
+    }
+    static cartesianEquation(center, radius) {
+        return equal(add(square(substract("x", center.x).simplify()), square(substract("y", center.y).simplify())), square(radius).simplify());
+    }
+}
 export class Circle {
     center;
     point;
@@ -7,6 +19,10 @@ export class Circle {
         this.point = point;
         this.name = name ?? "C";
     }
+    toCartesianEquation() {
+        const radius = this.center.distanceToNode(this.point).simplify();
+        return equal(add(square(substract("x", this.center.x).simplify()), square(substract("y", this.center.y).simplify())), square(radius).simplify());
+    }
     toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, } = // showUnderlyingPoints = true,
      {}) {
         const commands = [];