math-exercises 3.0.150 → 3.0.151

package/lib/exercises/math/spaceGeometry/sections/recognizeSectionsOfSphereOrBall.js

@@ -0,0 +1,236 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { strOfX, radius, isDiameterGiven } = identifiers;
+    return `Parmi les propositions suivantes, lesquelles peuvent être des sections planes ${strOfX} de ${isDiameterGiven ? "diamètre" : "rayon"} $${(isDiameterGiven ? 2 * radius : radius).frenchify()}\\ \\textrm{cm}$ ?`;
+};
+const getHint = (identifiers) => {
+    const { strOfX } = identifiers;
+    if (strOfX === "d'une sphère") {
+        return "Est-ce qu'une sphère est pleine ?";
+    }
+    else {
+        return "Est-ce qu'une boule est creuse ?";
+    }
+};
+const getCorrection = (identifiers) => {
+    const { strOfX, radius } = identifiers;
+    if (strOfX === "d'une sphère") {
+        return `On s'intéresse aux sections planes ${strOfX} de rayon $${radius} \\ \\textrm{cm}$.
+Les sections planes possibles sont : 
+- un point (quand le plan est tangent à la sphère)
+- tous les cercles de rayon inférieur ou égal à $${radius} \\ \\textrm{cm}$.
+
+La sphère est "creuse", les sections planes sont "creuses" elles aussi.`;
+    }
+    else {
+        return `On s'intéresse aux sections planes ${strOfX} de rayon $${radius} \\ \\textrm{cm}$.
+Les sections planes possibles sont : 
+- un point (quand le plan est tangent à la boule)
+- tous les disques de rayon inférieur ou égal à $${radius} \\ \\textrm{cm}$.
+
+La boule est "pleine", les sections planes sont "pleines" elles aussi.`;
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { strOfX, radius } = identifiers;
+    const propositions = [];
+    if (strOfX === "d'une sphère") {
+        const validPool = [
+            "un point",
+            //circle=radius
+            random([
+                `un cercle de rayon $${radius} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+            ]),
+            //circle<radius
+            random([
+                `un cercle de rayon $${randint(1, radius)} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * randint(1, radius)} \\ \\textrm{cm}$`,
+            ]),
+            //rare
+            ...(probaFlip(0.02)
+                ? [
+                    random([
+                        `un cercle de rayon $1,5 \\ \\textrm{cm}$`,
+                        `un cercle de diamètre $3 \\ \\textrm{cm}$`,
+                    ]),
+                ]
+                : []),
+        ];
+        const invalidPool = [
+            //circle>radius
+            random([
+                `un cercle de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+            //disk=radius
+            random([
+                `un disque de rayon $${radius} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+            ]),
+            //disk<radius
+            random([
+                `un disque de rayon $${randint(1, radius)} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * randint(1, radius)} \\ \\textrm{cm}$`,
+            ]),
+            //disk>radius
+            random([
+                `un disque de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+            //rare
+            ...(probaFlip(0.02)
+                ? [
+                    random([
+                        `un disque de rayon $1,5 \\ \\textrm{cm}$`,
+                        `un disque de diamètre $3 \\ \\textrm{cm}$`,
+                    ]),
+                ]
+                : []),
+        ];
+        const invalidMiscPool = ["une droite", "une ellipse", "un cône"];
+        if (coinFlip() && validPool.length === 4) {
+            //jackpot
+            validPool.forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+        }
+        else {
+            const nbValid = randint(1, validPool.length + 1);
+            const nbInvalid = n - nbValid;
+            randomMany(validPool, nbValid).forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+            if (probaFlip(0.2)) {
+                randomMany([...invalidPool, random(invalidMiscPool)], nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+            else {
+                randomMany(invalidPool, nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+        }
+    }
+    else {
+        const validPool = [
+            "un point",
+            //disk=radius
+            random([
+                `un disque de rayon $${radius} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+            ]),
+            //disk<radius
+            random([
+                `un disque de rayon $${randint(1, radius)} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * randint(1, radius)} \\ \\textrm{cm}$`,
+            ]),
+            //rare
+            ...(probaFlip(0.02)
+                ? [
+                    random([
+                        `un disque de rayon $1,5 \\ \\textrm{cm}$`,
+                        `un disque de diamètre $3 \\ \\textrm{cm}$`,
+                    ]),
+                ]
+                : []),
+        ];
+        const invalidPool = [
+            //disk>radius
+            random([
+                `un disque de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+            //circle=radius
+            random([
+                `un cercle de rayon $${radius} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+            ]),
+            //circle<radius
+            random([
+                `un cercle de rayon $${randint(1, radius)} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * randint(1, radius)} \\ \\textrm{cm}$`,
+            ]),
+            //circle>radius
+            random([
+                `un cercle de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+            //rare
+            ...(probaFlip(0.02)
+                ? [
+                    random([
+                        `un cercle de rayon $1,5 \\ \\textrm{cm}$`,
+                        `un cercle de diamètre $1,5 \\ \\textrm{cm}$`,
+                    ]),
+                ]
+                : []),
+        ];
+        const invalidMiscPool = ["une droite", "une ellipse", "un cône"];
+        if (coinFlip() && validPool.length === 4) {
+            //jackpot
+            validPool.forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+        }
+        else {
+            const nbValid = randint(1, validPool.length + 1);
+            const nbInvalid = n - nbValid;
+            randomMany(validPool, nbValid).forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+            if (probaFlip(0.2)) {
+                randomMany([...invalidPool, random(invalidMiscPool)], nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+            else {
+                randomMany(invalidPool, nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getRecognizeSectionsOfSphereOrBallQuestion = () => {
+    const strOfX = random(["d'une sphère", "d'une boule"]);
+    const radius = randint(5, 21);
+    const isDiameterGiven = coinFlip();
+    const identifiers = { strOfX, radius, isDiameterGiven };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+    };
+    return question;
+};
+export const recognizeSectionsOfSphereOrBall = {
+    id: "recognizeSectionsOfSphereOrBall",
+    connector: "=",
+    label: "Reconnaître la nature d'une section de sphère ou de boule",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getRecognizeSectionsOfSphereOrBallQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/pc/mathExosInPC.d.ts

@@ -7,10 +7,10 @@ export * from "../math/calcul/mentalCaluls/mentalAddAndSub.js";
 export { log10PowerSimplifying } from "../math/functions/logarithm/log10PowerSimplifying.js";
 export { log10SumSimplifying } from "../math/functions/logarithm/log10Simplifying.js";
 export { log10PowerEquation } from "../math/functions/logarithm/logPowerEquation.js";
-export * from "../math/calculLitteral/equation/equa1.js";
-export * from "../math/calculLitteral/equation/equa2.js";
-export * from "../math/calculLitteral/equation/equa3.js";
-export * from "../math/calculLitteral/equation/equa4.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa1.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa2.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa3.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa4.js";
 export * from "../math/geometry/vectors/scalarProduct/scalarProductViaCoords.js";
 export * from "../math/geometry/vectors/scalarProduct/scalarProductViaCos.js";
 export * from "../math/geometry/vectors/coordinatesReading.js";

package/lib/exercises/pc/mathExosInPC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mathExosInPC.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/mathExosInPC.ts"],"names":[],"mappings":"AAAA,yBAAyB;AACzB,cAAc,mCAAmC,CAAC;AAClD,cAAc,wDAAwD,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,cAAc,uCAAuC,CAAC;AACtD,cAAc,gDAAgD,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AACrF,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,kEAAkE,CAAC;AACjF,cAAc,+DAA+D,CAAC;AAC9E,cAAc,gDAAgD,CAAC;AAC/D,cAAc,sDAAsD,CAAC;AACrE,cAAc,mCAAmC,CAAC;AAClD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qDAAqD,CAAC;AACpE,cAAc,0CAA0C,CAAC;AACzD,cAAc,2DAA2D,CAAC;AAC1E,cAAc,uDAAuD,CAAC;AACtE,cAAc,6DAA6D,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,sBAAsB,EAAE,MAAM,oEAAoE,CAAC;AAC5G,cAAc,gDAAgD,CAAC;AAC/D,cAAc,iDAAiD,CAAC"}
+{"version":3,"file":"mathExosInPC.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/mathExosInPC.ts"],"names":[],"mappings":"AAAA,yBAAyB;AACzB,cAAc,mCAAmC,CAAC;AAClD,cAAc,wDAAwD,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,cAAc,uCAAuC,CAAC;AACtD,cAAc,gDAAgD,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AACrF,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,kEAAkE,CAAC;AACjF,cAAc,+DAA+D,CAAC;AAC9E,cAAc,gDAAgD,CAAC;AAC/D,cAAc,sDAAsD,CAAC;AACrE,cAAc,mCAAmC,CAAC;AAClD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qDAAqD,CAAC;AACpE,cAAc,0CAA0C,CAAC;AACzD,cAAc,2DAA2D,CAAC;AAC1E,cAAc,uDAAuD,CAAC;AACtE,cAAc,6DAA6D,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,sBAAsB,EAAE,MAAM,oEAAoE,CAAC;AAC5G,cAAc,gDAAgD,CAAC;AAC/D,cAAc,iDAAiD,CAAC"}

package/lib/exercises/pc/mathExosInPC.js

@@ -7,10 +7,10 @@ export * from "../math/calcul/mentalCaluls/mentalAddAndSub.js";
 export { log10PowerSimplifying } from "../math/functions/logarithm/log10PowerSimplifying.js";
 export { log10SumSimplifying } from "../math/functions/logarithm/log10Simplifying.js";
 export { log10PowerEquation } from "../math/functions/logarithm/logPowerEquation.js";
-export * from "../math/calculLitteral/equation/equa1.js";
-export * from "../math/calculLitteral/equation/equa2.js";
-export * from "../math/calculLitteral/equation/equa3.js";
-export * from "../math/calculLitteral/equation/equa4.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa1.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa2.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa3.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa4.js";
 export * from "../math/geometry/vectors/scalarProduct/scalarProductViaCoords.js";
 export * from "../math/geometry/vectors/scalarProduct/scalarProductViaCos.js";
 export * from "../math/geometry/vectors/coordinatesReading.js";

package/lib/index.d.ts

@@ -459,25 +459,6 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     a: number;
     b: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    isXRight: boolean;
-    aNumberType: string;
-}, {
-    aNumberType: string[];
-}> | Exercise<{
-    a: number;
-    b: number;
-    c: 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;
     c: number;
     d: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -488,21 +469,6 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    a: number;
-    b: number;
-    x: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    a: number;
-    x: number;
-    b: number;
-    c: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    a: number;
-    x: number;
-    b: number;
-    c: number;
-    d: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     type: number;
     vars: {
@@ -566,6 +532,47 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
+}, {
+    solutionFormat: string;
+}> | Exercise<{
+    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    isXRight: boolean;
+    aNumberType: string;
+}, {
+    aNumberType: string[];
+    solutionFormat: string;
+}> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+}, {
+    solutionFormat: string;
+}> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+}, {
+    solutionFormat: string;
+}> | Exercise<{
+    a: number;
+    b: number;
+    x: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    x: number;
+    b: number;
+    c: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    x: number;
+    b: number;
+    c: number;
+    d: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    b: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
@@ -1034,6 +1041,7 @@ declare const mathExercises: (Exercise<{
     yB: number;
 }, {
     functionType?: string;
+    coefType?: string;
 }> | Exercise<{
     xA: number;
     xB: number;
@@ -1065,7 +1073,9 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     isAskingA: boolean;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    parameter: string;
+}> | Exercise<{
     xValues: number[];
     yValues: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -1119,7 +1129,9 @@ declare const mathExercises: (Exercise<{
         isAnswer: boolean;
     }[];
     isLinear: boolean;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    functionType: string;
+}> | Exercise<{
     coeffs: number[];
     yValue: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -2049,7 +2061,9 @@ declare const mathExercises: (Exercise<{
     isSegmentHeight: boolean;
     pointsIdentifiers: import("./math/geometry/point.js").PointIdentifiers[];
     lengths: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    theorem: string;
+}> | Exercise<{
     point: string;
     line: string;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -2174,6 +2188,23 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
     angleAsked: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    namePoints1: string[];
+    namePoints2: string[];
+    nodeIdsLengths1: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    nodeIdsLengths2: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+}, {
+    numberTypesForLengths: ("Entier" | "D\u00E9cimal")[];
+    numberTypesForCoeffs: ("Entier" | "D\u00E9cimal" | "Fraction")[];
+}> | Exercise<{
+    triangleNames: string[];
+    sameAngleValue: number;
+    firstAngleValue: number;
+    secondAngleValue: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    triangleIds1: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+    triangleIds2: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+    factor: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     perimeter: number;
     askingX: boolean;
@@ -2657,6 +2688,13 @@ declare const mathExercises: (Exercise<{
     max: number;
     target: number;
     isIncluded: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    proba: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    knownEffectif: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xValues: number[];
+    yValues: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    atLeastXIndex: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     indexSituation: number;
     eventIds: {
@@ -2892,6 +2930,50 @@ declare const mathExercises: (Exercise<{
     h: number;
     askedPoint: string;
     givenPoints: string[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    strOfX: string;
+    radius: number;
+    isDiameterGiven: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    radius: number;
+    height: number;
+    isDiameterGiven: boolean;
+    isHollow: boolean;
+    isBaseCircle: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    radius: number;
+    height: number;
+    isDiameterGiven: boolean;
+    isHollow: boolean;
+    isBaseCircle: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nothing: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    isDiameterGiven: boolean;
+    radius: number;
+    height: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    isDiameterGiven: boolean;
+    radius: number;
+    height: number;
+    offset: number;
+    planeType: string;
+}, {
+    planeTypes: string[];
+}> | Exercise<{
+    isDiameterGiven: boolean;
+    radius: number;
+    height: number;
+    offset: number;
+    planeType: string;
+}, {
+    planeTypes: string[];
+}> | Exercise<{
+    AB: number;
+    AD: number;
+    AE: number;
+    offset: number;
+    planeType: string;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     sqrtOperand: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -3126,10 +3208,6 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     points: number[][];
     labels: string[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    bounds: number[];
-    data: number[];
-    itemAsked: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     quartiles: number[];
     arrQuartileIndex: (0 | 1 | 2 | 3 | 4)[];
@@ -3220,6 +3298,30 @@ declare const mathExercises: (Exercise<{
         }[];
         p: number;
     }[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    bounds: number[];
+    data: number[];
+    itemAsked: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    isMax: boolean;
+    bounds: number[];
+    data: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    histogram: {
+        bounds: number[];
+        data: number[];
+    };
+    table: {
+        bounds: number[];
+        data: number[];
+    } | undefined;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    bounds: number[];
+    data: number[];
+    initTable: string[][];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    bounds: number[];
+    data: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     epsilon: number;
     l: number;
@@ -3661,23 +3763,30 @@ declare const pcExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    solutionFormat: string;
+}> | Exercise<{
     a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     isXRight: boolean;
     aNumberType: string;
 }, {
     aNumberType: string[];
+    solutionFormat: string;
 }> | Exercise<{
     a: number;
     b: number;
     c: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    solutionFormat: string;
+}> | Exercise<{
     a: number;
     b: number;
     c: number;
     d: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    solutionFormat: string;
+}> | Exercise<{
     coefficients: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     coefficients: number[];

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+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/spacePoint.d.ts

@@ -1,11 +1,20 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
 import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps.js";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor.js";
+export type SpacePointIdentifiers = {
+    id: "spacePoint";
+    name: string;
+    x: NodeIdentifiers;
+    y: NodeIdentifiers;
+    z: NodeIdentifiers;
+};
 type AleaBound = {
     min?: number;
     max?: number;
     excludes?: number[];
 };
 export declare abstract class SpacePointConstructor {
+    static fromIdentifiers(identifiers: SpacePointIdentifiers): SpacePoint;
     static random(name: string, xOpts?: AleaBound, yOpts?: AleaBound, zOpts?: AleaBound): SpacePoint;
     static randomDifferent(names: string[]): SpacePoint[];
     static fromScalars(arr: number[], name?: string): SpacePoint;
@@ -16,6 +25,7 @@ export declare class SpacePoint {
     y: AlgebraicNode;
     z: AlgebraicNode;
     constructor(name: string, x: AlgebraicNode, y: AlgebraicNode, z: AlgebraicNode);
+    toIdentifiers(): SpacePointIdentifiers;
     getCoords(): AlgebraicNode[];
     getEvaluatedCoords(): number[];
     toMathString(): string;

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

@@ -1 +1 @@
-{"version":3,"file":"spacePoint.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spacePoint.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAE1F,KAAK,SAAS,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AACrE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,GAChB,UAAU;IAyBb,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;IAgCtC,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE,MAAY;CAWrD;AAED,qBAAa,UAAU;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IAQlB,SAAS;IAGT,kBAAkB;IAGlB,YAAY;IAGZ,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAKzB,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,UAAU;IAkBtB,UAAU,IAAI,MAAM;IAIpB,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAG9B,SAAS;IAOT,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;CAmB3B"}
+{"version":3,"file":"spacePoint.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spacePoint.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAE7C,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,EAAE,YAAY,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAEF,KAAK,SAAS,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AACrE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,qBAAqB;IASzD,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,GAChB,UAAU;IAyBb,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;IAgCtC,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE,MAAY;CAWrD;AAED,qBAAa,UAAU;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IAQlB,aAAa,IAAI,qBAAqB;IAUtC,SAAS;IAGT,kBAAkB;IAGlB,YAAY;IAGZ,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAKzB,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,UAAU;IAkBtB,UAAU,IAAI,MAAM;IAIpB,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAG9B,SAAS;IAOT,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;CAmB3B"}

package/lib/math/geometry/spacePoint.js

@@ -1,6 +1,10 @@
 import { NumberNode } from "../../tree/nodes/numbers/numberNode.js";
 import { randint } from "../utils/random/randint.js";
+import { NodeConstructor, } from "../../tree/nodes/nodeConstructor.js";
 export class SpacePointConstructor {
+    static fromIdentifiers(identifiers) {
+        return new SpacePoint(identifiers.name, NodeConstructor.fromIdentifiers(identifiers.x), NodeConstructor.fromIdentifiers(identifiers.y), NodeConstructor.fromIdentifiers(identifiers.z));
+    }
     static random(name, xOpts, yOpts, zOpts) {
         const x = randint(xOpts?.min ?? -9, xOpts?.max ?? 10, xOpts?.excludes ?? []);
         const y = randint(yOpts?.min ?? -9, yOpts?.max ?? 10, yOpts?.excludes ?? []);
@@ -46,6 +50,15 @@ export class SpacePoint {
         this.y = y;
         this.z = z;
     }
+    toIdentifiers() {
+        return {
+            id: "spacePoint",
+            name: this.name,
+            x: this.x.toIdentifiers(),
+            y: this.y.toIdentifiers(),
+            z: this.z.toIdentifiers(),
+        };
+    }
     getCoords() {
         return [this.x, this.y, this.z];
     }

package/lib/tree/nodes/operators/substractNode.d.ts

@@ -26,6 +26,7 @@ export declare class SubstractNode implements OperatorNode {
     toAllValidTexs(): string[];
     dangerouslyShuffle(): void;
     toTex(options?: ToTexOptions): string;
+    toSimplificationTex(opts?: SimplifyOptions): string;
     evaluate(vars?: Record<string, number>): number;
     simplify(opts?: SimplifyOptions): AlgebraicNode;
     equals(node: AlgebraicNode): boolean;