math-exercises 3.0.84 → 3.0.85

package/lib/exercises/math/probaStat/basicStats/index.js

@@ -1,2 +1,3 @@
 export * from "./calculateFrequency.js";
 export * from "./calculateFrequencyInList.js";
+export * from "./samplingFrequency.js";

package/lib/exercises/math/probaStat/basicStats/samplingFrequency.d.ts

@@ -0,0 +1,7 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    samples: number[];
+};
+export declare const samplingFrequency: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=samplingFrequency.d.ts.map

package/lib/exercises/math/probaStat/basicStats/samplingFrequency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"samplingFrequency.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicStats/samplingFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAwGF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAoBnD,CAAC"}

package/lib/exercises/math/probaStat/basicStats/samplingFrequency.js

@@ -0,0 +1,106 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { average } from "../../../../utils/average.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const samples = identifiers.samples;
+    const avg = average(samples);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, round(avg + (coinFlip() ? randint(10, 30) / 100 : randint(-30, -10) / 100), 2).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const avg = average(identifiers.samples);
+    return round(avg, 1).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const length = identifiers.samples.length;
+    return `Ce graphique donne les fréquences $${length}$ échantillons d'une expérience aléatoire. Estimer la probabilité de l'évènement $A$.`;
+};
+const getHint = (identifiers) => {
+    return `Chaque échantillon donne une valeur approximative proche de la probabilité réelle. 
+  
+Tu peux estimer cette probabilité en déterminant graphiquement la moyenne des fréquences des échantillons.`;
+};
+const getCorrection = (identifiers) => {
+    const { samples } = identifiers;
+    const avg = getAnswer(identifiers);
+    return `On lit graphiquement que la moyenne des fréquences est environ $${avg}$. Puisque le nombre d'échantillons est suffisant, on peut donc estimer que la probabilité de l'évènement $A$ vaut environ $${avg}$.`;
+};
+const getGGBOptions = (identifiers) => {
+    const commands = identifiers.samples.map((y, idx) => `(${idx}, ${y})`);
+    const yMax = Math.max(...identifiers.samples);
+    const ggb = new GeogebraConstructor({
+        commands,
+        lockedAxesRatio: 5,
+        gridDistance: [1, 0.1],
+        xAxis: {
+            showPositive: true,
+            label: "N° d'échantillon",
+        },
+        yAxis: {
+            label: "Fréquence de l'évènement A",
+        },
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: [-1, identifiers.samples.length + 1, -0.1, yMax + 0.3],
+    });
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    // On autorise une erreur de +/- 5% sur la frequence moyenne
+    const ev = parseAlgebraic(ans).evaluate();
+    const ansEv = parseAlgebraic(answer).evaluate();
+    return Math.abs(ev - ansEv) < 5 / 100;
+};
+const getSamplingFrequencyQuestion = (opts) => {
+    const freq = randint(2, 10) * 10; // multiple de 10 pour simplifier l'estimation pour l'utilisateur
+    let samples = [];
+    const length = randint(9, 14);
+    for (let i = 0; i < length; i++) {
+        samples.push(round((freq + randint(-10, 10)) / 100, 2));
+    }
+    const identifiers = { samples };
+    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),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const samplingFrequency = {
+    id: "samplingFrequency",
+    label: "Estimer une probabilité à partir d'un graphique de fréquences pour un nombre suffisant d'échantillons",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSamplingFrequencyQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/probaStat/getQuartileProportionQuestion.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    labels: string[];
+    serie1: number[];
+    serie2: number[];
+    a: number;
+    b: number;
+    isBetween: boolean;
+};
+export declare const getQuartileProportionQuestion: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=getQuartileProportionQuestion.d.ts.map

package/lib/exercises/math/probaStat/getQuartileProportionQuestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getQuartileProportionQuestion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/getQuartileProportionQuestion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAwMF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAqB/D,CAAC"}

package/lib/exercises/math/probaStat/getQuartileProportionQuestion.js

@@ -0,0 +1,178 @@
+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 { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { dollarize } from "../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../utils/markdown/mdTable.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Série $1$", "raw");
+    tryToAddWrongProp(propositions, "Série $2$", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = ({ serie1, serie2, a, b, isBetween, }) => {
+    const mainSeries = serie1.includes(b) ? serie1 : serie2;
+    const otherSeries = mainSeries === serie1 ? serie2 : serie1;
+    const indexOfB = mainSeries.indexOf(b);
+    const indexOfA = mainSeries.indexOf(a);
+    const diff = indexOfB - indexOfA + 1;
+    let count = 0;
+    for (let idx = 0; idx < otherSeries.length; idx++) {
+        const val = otherSeries[idx];
+        if (isBetween) {
+            if ((val >= a || otherSeries[idx + 1] > a) &&
+                (val <= b || otherSeries[idx - 1] < b)) {
+                count++;
+            }
+        }
+        else {
+            if (val < b) {
+                count++;
+            }
+        }
+    }
+    const mainSeriesText = mainSeries === serie1 ? "Série $1$" : "Série $2$";
+    const otherSeriesText = mainSeries === serie1 ? "Série $2$" : "Série $1$";
+    const condition = isBetween ? diff >= count : indexOfB < count;
+    return condition ? mainSeriesText : otherSeriesText;
+};
+const getInstruction = ({ labels, serie1, serie2, a, b, isBetween, }) => {
+    const question = isBetween
+        ? `Quelle série a la plus grande proportion de valeurs entre $${a}$ et $${b}$ ?`
+        : `Quelle série a la plus grande proportion de valeurs supérieures à $${b}$ ?`;
+    return (`${question}\n\n` +
+        mdTable([
+            ["", ...labels.map((l, i) => (i === 1 || i === 3 ? dollarize(l) : l))],
+            ["Série $1$", ...serie1.map((l) => dollarize(l))],
+            ["Série $2$", ...serie2.map((l) => dollarize(l))],
+        ]));
+};
+const getHint = (identifiers) => {
+    return `
+Les quartiles permettent de découper une série en quatre parties égales :
+
+- $Q_1$ (premier quartile) : au moins $25 \\%$ des valeurs sont inférieures ou égales à cette valeur.
+- Médiane : au moins $50 \\%$ des valeurs sont inférieures ou égales à cette valeur.
+- $Q_3$ (troisième quartile) : au moins $75 \\%$ des valeurs sont inférieures ou égales à cette valeur.
+`;
+};
+const getCorrection = (identifiers) => {
+    const { labels, serie1, serie2, a, b, isBetween } = identifiers;
+    const isBInSerie1 = serie1.includes(b);
+    const mainSeries = isBInSerie1 ? serie1 : serie2;
+    const otherSeries = isBInSerie1 ? serie2 : serie1;
+    const mainSeriesLabel = isBInSerie1 ? "série $1$" : "série $2$";
+    const otherSeriesLabel = isBInSerie1 ? "série $2$" : "série $1$";
+    const indexOfA = mainSeries.indexOf(a);
+    const indexOfB = mainSeries.indexOf(b);
+    let i = 0;
+    for (let idx = 0; idx < otherSeries.length; idx++) {
+        const val = otherSeries[idx];
+        if (isBetween) {
+            if ((val >= a || otherSeries[idx + 1] > a) &&
+                (val <= b || otherSeries[idx - 1] < b)) {
+                i++;
+            }
+        }
+        else {
+            if (val < b) {
+                i++;
+            }
+        }
+    }
+    const quartilePercentages = [0, 25, 50, 75, 100];
+    const labelA = labels[indexOfA];
+    const labelB = labels[indexOfB];
+    const valueA = a;
+    const valueB = b;
+    const diff = indexOfB - indexOfA + 1;
+    const percentageBetween = quartilePercentages[diff - 1];
+    const percentageAbove = 100 - quartilePercentages[indexOfB];
+    const answer = getAnswer(identifiers);
+    const answerFormatted = answer === "Série $1$" ? "série $1$" : "série $2$";
+    const decideWord = answerFormatted === mainSeriesLabel ? "moins" : "plus";
+    const proportionB = isBetween
+        ? `$${percentageBetween}\\%$ des valeurs sont entre $${valueA}$ et $${valueB}$.\n\n`
+        : `$${percentageAbove}\\%$ des valeurs sont supérieures à $${valueB}$.\n\n`;
+    const proportionOther = i === 0
+        ? `Il n'y a aucune valeur dans l'intervalle $[${valueA}; ${valueB}]$.\n\n`
+        : isBetween
+            ? `${decideWord} $${percentageBetween}\\%$ des valeurs sont entre $${valueA}$ et $${valueB}$.\n\n`
+            : `${otherSeries[indexOfB] > valueB ? "plus" : "moins"} de $${100 - quartilePercentages[i - 1]}\\%$ des valeurs sont supérieures à $${valueB}$.\n\n`;
+    const comparison = isBetween
+        ? `La ${answer} a donc une proportion plus grande de valeurs dans l'intervalle.`
+        : `La ${answer} a donc une proportion plus grande de valeurs supérieures à $${valueB}$.`;
+    return isBetween
+        ? `On peut estimer cette proportion en observant la position des valeurs $${valueA}$ et $${valueB}$ dans chaque série :
+    
+  - Dans la ${mainSeriesLabel}, on a $${labelA} = ${valueA}$ et $${labelB} = ${valueB}$, donc ${proportionB}
+  - Dans la ${otherSeriesLabel}, on a $${labelA} = ${otherSeries[indexOfA]}$ et $${labelB} = ${otherSeries[indexOfB]}$, donc ${proportionOther}
+  
+  ${comparison}`
+        : `On peut estimer cette proportion en observant la position de la valeur $${valueB}$ dans chaque série :
+  
+  - Dans la ${mainSeriesLabel}, on a $${labelB} = ${valueB}$, donc ${proportionB}
+  - Dans la ${otherSeriesLabel}, on a $${labelB} = ${otherSeries[indexOfB]}$, ${proportionOther}
+  
+  ${comparison}`;
+};
+const getKeys = () => [];
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const makeQuartileSeries = (min, exclude) => {
+    const serie = [min];
+    for (let i = 0; i < 4; i++) {
+        const prev = serie[serie.length - 1];
+        serie.push(randint(prev + 1, prev + 6, exclude));
+    }
+    return serie;
+};
+const getGetQuartileProportionQuestionQuestion = () => {
+    const labels = ["Min", "Q_1", "Méd", "Q_3", "Max"];
+    const min = randint(0, 10);
+    const serie1 = makeQuartileSeries(min);
+    const serie2 = makeQuartileSeries(min, serie1);
+    const isBetween = coinFlip();
+    const chosenSerie = coinFlip() ? serie1 : serie2;
+    const indexOfA = randint(0, serie1.length - (isBetween ? 1 : 2));
+    const a = chosenSerie[indexOfA];
+    const indexOfB = randint(indexOfA + 1, isBetween ? chosenSerie.length : chosenSerie.length - 1);
+    const b = chosenSerie[indexOfB];
+    const identifiers = { labels, serie1, serie2, a, b, isBetween };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => ({
+    answer: getAnswer(identifiers),
+    instruction: getInstruction(identifiers),
+    keys: getKeys(identifiers),
+    answerFormat: "raw",
+    identifiers,
+    hint: getHint(identifiers),
+    correction: getCorrection(identifiers),
+});
+export const getQuartileProportionQuestion = {
+    id: "getQuartileProportionQuestion",
+    label: "Comparer et interpréter les indicateurs de deux séries statistiques",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGetQuartileProportionQuestionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -14,4 +14,5 @@ export * from "./checkEquiprobability.js";
 export * from "./getSampleCountAndSize.js";
 export * from "./events/index.js";
 export * from "./basicProbas/index.js";
+export * from "./getQuartileProportionQuestion.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oCAAoC,CAAC"}

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

@@ -14,3 +14,4 @@ export * from "./checkEquiprobability.js";
 export * from "./getSampleCountAndSize.js";
 export * from "./events/index.js";
 export * from "./basicProbas/index.js";
+export * from "./getQuartileProportionQuestion.js";

package/lib/exercises/math/probaStat/stats1var/choseReasoningForIndicator.d.ts

@@ -3,6 +3,9 @@ type Identifiers = {
     indicatorAsked: string;
     values: number[];
 };
-export declare const choseReasoningForIndicator: Exercise<Identifiers>;
+type Options = {
+    indicators: string[];
+};
+export declare const choseReasoningForIndicator: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=choseReasoningForIndicator.d.ts.map

package/lib/exercises/math/probaStat/stats1var/choseReasoningForIndicator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"choseReasoningForIndicator.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/choseReasoningForIndicator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAgIF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAa5D,CAAC"}
+{"version":3,"file":"choseReasoningForIndicator.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/choseReasoningForIndicator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA2IF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBrE,CAAC"}

package/lib/exercises/math/probaStat/stats1var/choseReasoningForIndicator.js

@@ -1,4 +1,4 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
@@ -6,6 +6,16 @@ import { operatorComposition } from "../../../../tree/utilities/operatorComposit
 import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { average } from "../../../../utils/average.js";
+const options = [
+    {
+        id: "indicators",
+        label: "Indicateurs",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: ["Moyenne", "Médiane"],
+        values: ["Moyenne", "Médiane"],
+    },
+];
 const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     addValidProp(propositions, answer, "raw");
@@ -52,7 +62,7 @@ const getCorrection = (identifiers) => {
         : `La médiane est la valeur centrale de la série : c'est à dire qu'il y a autant de valeurs inférieures à elle que de valeurs supérieures. Ici, ${getAnswer(identifiers).toLocaleLowerCase()}.
 `;
 };
-const getChoseReasoningForIndicatorQuestion = (ops) => {
+const getChoseReasoningForIndicatorQuestion = (opts) => {
     const max = 2 * randint(5, 20);
     const x = max / 2;
     let otherValues = [];
@@ -74,18 +84,18 @@ const getChoseReasoningForIndicatorQuestion = (ops) => {
     shuffled.splice(3, 0, x);
     const identifiers = {
         values: shuffled,
-        indicatorAsked: random(["moyenne", "médiane"]),
+        indicatorAsked: random(opts?.indicators ?? ["moyenne", "médiane"]),
     };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
         answerFormat: "raw",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
@@ -101,4 +111,8 @@ export const choseReasoningForIndicator = {
     answerType: "QCU",
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    options,
+    pdfOptions: {
+        shouldSpreadPropositions: true,
+    },
 };

package/lib/index.d.ts

@@ -106,6 +106,12 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     expr: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     x: number;
+}, {}> | Exercise<{
+    type: number;
+    expr: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    point: import("./math/geometry/point.js").PointIdentifiers;
+    bounding: number;
 }, {}> | Exercise<{
     integerFirst: boolean;
     integer: number;
@@ -182,6 +188,11 @@ declare const mathExercises: (Exercise<{
     a: number;
     n: number;
     isSimplified: boolean;
+}, {}> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
 }, {}> | Exercise<{
     numbers: number[];
 }, {}> | Exercise<{
@@ -895,9 +906,6 @@ declare const mathExercises: (Exercise<{
     inegalitySymbol: import("./math/inequations/inequation.js").InegalitySymbols;
     a: number;
     b: number;
-}, {}> | Exercise<{
-    coeffs: number[];
-    initTable: string[][];
 }, {}> | Exercise<{
     k: number;
 }, {}> | Exercise<{
@@ -1565,6 +1573,8 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
     angleAsked: number;
+}, {}> | Exercise<{
+    intervalNodeIdentifiers: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
 }, {}> | Exercise<{
     coeffs: number[];
     to: "+\\infty" | "-\\infty";
@@ -1822,7 +1832,9 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     indicatorAsked: string;
     values: number[];
-}, {}> | Exercise<{
+}, {
+    indicators: string[];
+}> | Exercise<{
     labels: number[];
     serie1: number[];
     serie2: number[];
@@ -1908,6 +1920,8 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     values: number[];
     target: number;
+}, {}> | Exercise<{
+    samples: number[];
 }, {}> | Exercise<{
     xValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     yValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
@@ -1976,6 +1990,13 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<MathExercises.Identifiers, {}> | Exercise<{
     a: number;
     type: number;
+}, {}> | Exercise<{
+    labels: string[];
+    serie1: number[];
+    serie2: number[];
+    a: number;
+    b: number;
+    isBetween: boolean;
 }, {}> | Exercise<{
     firstValue: number;
     askedRank: 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;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,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;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

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

@@ -44,7 +44,7 @@ export declare class Point {
     equals(B: Point): boolean;
     isAligned(B: Point, C: Point): boolean;
     toMathString(): string;
-    toGGBCommand({ isFixed, showLabel, style, size, color, }?: ToGGBCommandsProps): string[];
+    toGGBCommand({ isFixed, showLabel, style, size, color, label, }?: ToGGBCommandsProps): string[];
     rotate(angle: number, center: Point): Point;
     centralSymetric(center: Point, name?: string): Point;
     project(line: Line, name?: string): Point;

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

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAG3C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAM7C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AACF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrC,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM;IAKhC,MAAM,CAAC,MAAM,CAAC,IAAI,SAAM;IAGxB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAM,EAAE,GAAG,SAAK,GAAG,KAAK;IAMvD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;IAQpD,MAAM,CAAC,SAAS,CACd,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,EACE,OAAa,EACb,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;IAQpD,MAAM,CAAC,eAAe,CACpB,KAAK,EAAE,MAAM,EACb,EACE,KAAK,EACL,WAAW,EACX,mBAAmB,GACpB,EAAE;QACD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B;IA4BH,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,CAAC,EAAE,aAAa,GAAG,MAAM;IAO3B,KAAK,IAAI,MAAM;IAGf,aAAa,IAAI,gBAAgB;IAQjC,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAOzC,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAQrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAK5B,cAAc,CAAC,CAAC,EAAE,KAAK,GAAG,aAAa;IAMvC,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAK5B,YAAY;IAGZ,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;IAiB1B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;IAiBnC,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,SAAkB;IAIrD,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;IAI1C,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;IAKhD,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;CAGhC"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAG3C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAM7C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AACF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrC,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM;IAKhC,MAAM,CAAC,MAAM,CAAC,IAAI,SAAM;IAGxB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAM,EAAE,GAAG,SAAK,GAAG,KAAK;IAMvD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;IAQpD,MAAM,CAAC,SAAS,CACd,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,EACE,OAAa,EACb,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;IAQpD,MAAM,CAAC,eAAe,CACpB,KAAK,EAAE,MAAM,EACb,EACE,KAAK,EACL,WAAW,EACX,mBAAmB,GACpB,EAAE;QACD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B;IA4BH,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,CAAC,EAAE,aAAa,GAAG,MAAM;IAO3B,KAAK,IAAI,MAAM;IAGf,aAAa,IAAI,gBAAgB;IAQjC,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAOzC,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAQrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAK5B,cAAc,CAAC,CAAC,EAAE,KAAK,GAAG,aAAa;IAMvC,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAK5B,YAAY;IAGZ,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,EACL,KAAK,GACN,GAAE,kBAAuB;IAoB1B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;IAiBnC,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,SAAkB;IAIrD,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;IAI1C,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;IAKhD,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;CAGhC"}

package/lib/math/geometry/point.js

@@ -123,12 +123,15 @@ export class Point {
     toMathString() {
         return `(${this.x.toMathString()}, ${this.y.toMathString()})`;
     }
-    toGGBCommand({ isFixed = true, showLabel = true, style, size, color, } = {}) {
+    toGGBCommand({ isFixed = true, showLabel = true, style, size, color, label, } = {}) {
         const commands = [
             `${this.name} = (${this.x.toMathString()}, ${this.y.toMathString()})`,
             `SetFixed(${this.name},${isFixed ? "true" : "false"})`,
             `ShowLabel(${this.name},${showLabel ? "true" : "false"})`,
         ];
+        if (label !== undefined) {
+            commands.push(`SetCaption(${this.name}, "${label}")`);
+        }
         if (style !== undefined) {
             commands.push(`SetPointStyle(${this.name}, ${style})`);
         }

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAmCA,eAAO,MAAM,UAAU,YAUtB,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAmCA,eAAO,MAAM,UAAU,YAAW,CAAC"}

package/lib/playground.js

@@ -1,11 +1 @@
-import { frac } from "./tree/nodes/operators/fractionNode.js";
-import { multiply } from "./tree/nodes/operators/multiplyNode.js";
-export const playground = () => {
-    console.log(multiply(frac(1, 3), frac(-1, 3))
-        .simplify({
-        towardsDistribute: true,
-        forbidFactorize: true,
-        forceDistributeFractions: true,
-    })
-        .toTex());
-};
+export const playground = () => { };

package/lib/tests/exoTest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exoTest.d.ts","sourceRoot":"","sources":["../../src/tests/exoTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAIvD,eAAO,MAAM,OAAO,QAAS,QAAQ;;;;CAuFpC,CAAC"}
+{"version":3,"file":"exoTest.d.ts","sourceRoot":"","sources":["../../src/tests/exoTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAIvD,eAAO,MAAM,OAAO,QAAS,QAAQ;;;;CA8EpC,CAAC"}

package/lib/tests/exoTest.js

@@ -19,16 +19,13 @@ export const exoTest = (exo) => {
     const questions = exo.generator(30);
     let after = Date.now();
     generatorTime = after - before;
-    if (exo.answerType !== "free" &&
-        exo.answerType !== "GGB" &&
-        exo.answerType !== "valueTable") {
+    if (exo.answerType !== "free" && exo.answerType !== "GGB") {
         if (!exo.getPropositions)
             throw new Error(`exo ${exo.id} has no getPropositions`);
     }
     if (exo.answerType !== "QCM" &&
         exo.answerType !== "QCU" &&
-        exo.answerType !== "GGB" &&
-        exo.answerType !== "valueTable") {
+        exo.answerType !== "GGB") {
         if (!exo.isAnswerValid)
             throw new Error(`exo ${exo.id} has no isAnswerValid`);
     }
@@ -36,10 +33,6 @@ export const exoTest = (exo) => {
         if (!exo.isGGBAnswerValid)
             throw new Error(`exo ${exo.id} has no isGGBAnswerValid`);
     }
-    if (exo.answerType === "valueTable") {
-        if (!exo.isAnswerTableValid)
-            throw new Error(`exo ${exo.id} has no isAnswerTableValid`);
-    }
     questions.forEach((question) => {
         const times = questionTest(exo, question);
         qcmTime = times.qcmTime;

package/lib/tests/questionTest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAIjE,eAAO,MAAM,YAAY,QAAS,QAAQ,YAAY,QAAQ;;;CAuM7D,CAAC"}
+{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAIjE,eAAO,MAAM,YAAY,QAAS,QAAQ,YAAY,QAAQ;;;CAoL7D,CAAC"}