math-exercises 3.0.87 → 3.0.88

package/lib/exercises/math/functions/basics/index.d.ts

@@ -10,4 +10,5 @@ export * from "./inverseImageFunctionTable.js";
 export * from "./imageAntecedentFromSentence.js";
 export * from "./graphicInequationAffine.js";
 export * from "./valueTableCompletion.js";
+export * from "./valueTableFromGraph.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/basics/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC"}

package/lib/exercises/math/functions/basics/index.js

@@ -10,3 +10,4 @@ export * from "./inverseImageFunctionTable.js";
 export * from "./imageAntecedentFromSentence.js";
 export * from "./graphicInequationAffine.js";
 export * from "./valueTableCompletion.js";
+export * from "./valueTableFromGraph.js";

package/lib/exercises/math/functions/basics/valueTableFromGraph.d.ts

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

package/lib/exercises/math/functions/basics/valueTableFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueTableFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/valueTableFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;CACvB,CAAC;AAkIF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAmBrD,CAAC"}

package/lib/exercises/math/functions/basics/valueTableFromGraph.js

@@ -0,0 +1,139 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randomColor } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { numberParser } from "../../../../tree/parsers/numberParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getAnswerTable = (identifiers) => {
+    const { points, initTable } = identifiers;
+    const answerTable = [[], []];
+    for (let j = 1; j < initTable[0].length; j++) {
+        if (initTable[0][j] === "") {
+            answerTable[0].push(points
+                .find((p) => p[1] === Number(initTable[1][j]))[0]
+                .toTree()
+                .toTex());
+            answerTable[1].push(initTable[1][j]);
+        }
+        else {
+            answerTable[1].push(points
+                .find((p) => p[0] === Number(initTable[0][j]))[1]
+                .toTree()
+                .toTex());
+            answerTable[0].push(initTable[0][j]);
+        }
+    }
+    return [
+        ["x", ...answerTable[0]],
+        ["f(x)", ...answerTable[1]],
+    ];
+};
+const getInstruction = (identifiers) => {
+    return `Soit $f$ la fonction dont la courbe représentative est tracée ci-dessous. 
+  
+Compléter le tableau de valeurs de $f$.`;
+};
+const getGGBOptions = (identifiers) => {
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `S = Spline(${identifiers.points
+                .map((point) => `(${point[0]},${point[1]})`)
+                .join(",")})`,
+            "SetFixed(S, true)",
+            `SetColor(S, "${randomColor()}")`,
+        ],
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(identifiers.points.map((point) => new Point("A", point[0], point[1]))),
+    });
+};
+const getHint = (identifiers) => {
+    return "Dans un tableau de valeurs, la deuxième ligne contient les images de la première ligne par la fonction $f$. Pour trouver une case de la deuxième ligne, il faut donc lire graphiquement l'image du nombre de la première ligne par la fonction $f$.";
+};
+const getCorrection = (identifiers) => {
+    return `
+On lit graphiquement que : 
+
+${identifiers.points.map((p) => `- $f(${p[0]}) = ${p[1]}$`).join("\n")}
+
+Le tableau de valeurs complété est donc : 
+
+${mdTable(getAnswerTable(identifiers), true)}
+
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        for (let i = 0; i < 2; i++) {
+            for (let j = 1; j < ans[i].length; j++) {
+                const ansParsed = numberParser(ans[i][j]);
+                const answerParsed = numberParser(answerTable[i][j]);
+                const valid = ansParsed === answerParsed;
+                if (!valid)
+                    return false;
+            }
+        }
+        return true;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getValueTableFromGraphQuestion = (ops) => {
+    const xs = [randint(-10, -5), randint(-5, 0), randint(0, 5), randint(6, 10)];
+    const points = [[xs[0], randint(-9, 10)]];
+    for (let i = 1; i < xs.length; i++) {
+        let y = points[i - 1][1] + randint(-5, 6);
+        points.push([xs[i], y]);
+    }
+    let stringXs = points.map((p) => p[0].toString());
+    const ys = [];
+    for (let i = 0; i < stringXs.length; i++) {
+        ys.push("");
+    }
+    const initTable = [
+        ["x", ...stringXs],
+        ["f(x)", ...ys],
+    ];
+    const identifiers = {
+        points: points,
+        initTable,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: identifiers.initTable,
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const valueTableFromGraph = {
+    id: "valueTableFromGraph",
+    connector: "=",
+    label: "Compléter un tableau de valeurs d'une fonction à partir d'un graphique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getValueTableFromGraphQuestion(opts), nb),
+    valueTableTimer: 120,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "valueTable",
+    isAnswerTableValid,
+    hasGeogebra: true,
+};

package/lib/exercises/math/percent/evolutions/globalCM.d.ts

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

package/lib/exercises/math/percent/evolutions/globalCM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalCM.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/percent/evolutions/globalCM.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAoFF,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAmB1C,CAAC"}

package/lib/exercises/math/percent/evolutions/globalCM.js

@@ -0,0 +1,89 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randfloat(0, 2, 4).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { evolutions } = identifiers;
+    const cms = evolutions.map((e) => round(1 + e / 100, 4));
+    return round(cms.reduce((acc, curr) => acc * curr, 1), 4).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { evolutions } = identifiers;
+    return `Déterminer le coefficient multiplicateur associé à une ${evolutions[0] > 0 ? "hausse" : "baisse"} de $${Math.abs(evolutions[0])}\\%$ suivie d'une ${evolutions[1] > 0 ? "hausse" : "baisse"} de $${Math.abs(evolutions[1])}\\%$. `;
+};
+const getHint = (identifiers) => {
+    return `Détermine les coefficients multiplicateurs de chacune des évolutions. Puis, multiplie ces coefficients multiplicateurs.`;
+};
+const getCorrection = (identifiers) => {
+    const { evolutions } = identifiers;
+    const cms = evolutions.map((e) => round(1 + e / 100, 4));
+    return `Le coefficient multiplicateur associé à une ${evolutions[0] > 0 ? "hausse" : "baisse"} de $${Math.abs(evolutions[0])}\\%$ est $${cms[0].frenchify()}$. 
+  
+Le coefficient multiplicateur associé à une ${evolutions[1] > 0 ? "hausse" : "baisse"} de $${Math.abs(evolutions[1])}\\%$ est $${cms[1].frenchify()}$.
+
+Pour déterminer le coefficient multiplicateur global, on multiplie ces deux coefficients multiplicateurs : 
+
+$$
+${multiply(cms[0], cms[1]).toTex()}=${getAnswer(identifiers)}
+$$
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGlobalCmQuestion = (ops) => {
+    const evolutions = [randint(-99, 101, [0]), randint(-99, 101, [0])];
+    const identifiers = {
+        evolutions,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const globalCM = {
+    id: "globalCM",
+    connector: "=",
+    label: "Calculer le coefficient multiplicateur associé à deux évolutions successives",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGlobalCmQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/percent/evolutions/index.d.ts

@@ -8,4 +8,5 @@ export * from "./evolutionRateFromValues.js";
 export * from "./findStartValueAfterEvolution.js";
 export * from "./findEndValueAfterEvolution.js";
 export * from "./findRightCalculForPriceEvolution.js";
+export * from "./globalCM.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/percent/evolutions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/percent/evolutions/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mCAAmC,CAAC;AAClD,cAAc,iCAAiC,CAAC;AAChD,cAAc,uCAAuC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/percent/evolutions/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mCAAmC,CAAC;AAClD,cAAc,iCAAiC,CAAC;AAChD,cAAc,uCAAuC,CAAC;AACtD,cAAc,eAAe,CAAC"}

package/lib/exercises/math/percent/evolutions/index.js

@@ -8,3 +8,4 @@ export * from "./evolutionRateFromValues.js";
 export * from "./findStartValueAfterEvolution.js";
 export * from "./findEndValueAfterEvolution.js";
 export * from "./findRightCalculForPriceEvolution.js";
+export * from "./globalCM.js";

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

@@ -9,4 +9,5 @@ export * from "./populationEffectifFromSubPopulation.js";
 export * from "./percentWritings.js";
 export * from "./evolutions/index.js";
 export * from "./interests/index.js";
+export * from "./percentOfPercent.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,uCAAuC,CAAC;AACtD,cAAc,0CAA0C,CAAC;AACzD,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,uCAAuC,CAAC;AACtD,cAAc,0CAA0C,CAAC;AACzD,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC"}

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

@@ -9,3 +9,4 @@ export * from "./populationEffectifFromSubPopulation.js";
 export * from "./percentWritings.js";
 export * from "./evolutions/index.js";
 export * from "./interests/index.js";
+export * from "./percentOfPercent.js";

package/lib/exercises/math/percent/percentOfPercent.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    x: number;
+    y: number;
+};
+export declare const percentOfPercent: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=percentOfPercent.d.ts.map

package/lib/exercises/math/percent/percentOfPercent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"percentOfPercent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/percentOfPercent.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA0EF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAkBlD,CAAC"}

package/lib/exercises/math/percent/percentOfPercent.js

@@ -0,0 +1,89 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { percentParser } from "../../../tree/parsers/percentParser.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randfloat(1, 100, 2).frenchify() + "\\%");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { x, y } = identifiers;
+    return `${round((x / 100) * y, 4).frenchify()}\\%`;
+};
+const getInstruction = (identifiers) => {
+    const { x, y } = identifiers;
+    return `Quel pourcentage est égal à $${x}\\ \\%$ de $${y}\\ \\%$ ?`;
+};
+const getHint = (identifiers) => {
+    return `Pour calculer $x\\%$ de $y\\%$, tu peux multiplier les deux pourcentages.`;
+};
+const getCorrection = (identifiers) => {
+    const { x, y } = identifiers;
+    return `On calcule $${x}\\%$ de $${y}$ : 
+
+$$
+${multiply(frac(x, 100), y).toTex()} = ${round((x / 100) * y, 4).frenchify()}
+$$
+
+Le pourcentage égal à $${x}\\%$ de $${y}\\%$ est donc $${getAnswer(identifiers)}$.
+
+  `;
+};
+const getKeys = (identifiers) => {
+    return ["percent"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = percentParser(ans);
+        if (!parsed)
+            return false;
+        return parsed === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPercentOfPercentQuestion = (ops) => {
+    const x = randint(1, 100);
+    const y = randint(1, 100);
+    const identifiers = { x, y };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const percentOfPercent = {
+    id: "percentOfPercent",
+    connector: "=",
+    label: "Calculer un pourcentage de pourcentage",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPercentOfPercentQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/geogebra/spline.d.ts

@@ -1,7 +1,8 @@
 import { Point } from "../math/geometry/point.js";
 import { IntervalNode } from "../tree/nodes/sets/intervalNode.js";
 export declare abstract class SplineConstructor {
-    random(): Spline;
+    static random(): Spline;
+    static getAdequatePoints(nbOfPoints?: number): [number, number][];
 }
 export declare class Spline {
     points: number[][];

package/lib/geogebra/spline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline.d.ts","sourceRoot":"","sources":["../../src/geogebra/spline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAIrD,OAAO,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AAKrE,8BAAsB,iBAAiB;IACrC,MAAM;CAQP;AACD,qBAAa,MAAM;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}
+{"version":3,"file":"spline.d.ts","sourceRoot":"","sources":["../../src/geogebra/spline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAIrD,OAAO,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AAKrE,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM;IASb,MAAM,CAAC,iBAAiB,CAAC,UAAU,SAAI;CAsCxC;AACD,qBAAa,MAAM;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}

package/lib/geogebra/spline.js

@@ -2,14 +2,52 @@ import { randfloat } from "../math/utils/random/randfloat.js";
 import { randint } from "../math/utils/random/randint.js";
 import { ClosureType } from "../tree/nodes/sets/closure.js";
 import { IntervalNode } from "../tree/nodes/sets/intervalNode.js";
+import { coinFlip } from "../utils/alea/coinFlip.js";
 import { doWhile } from "../utils/doWhile.js";
 import { randomColor } from "./colors.js";
 export class SplineConstructor {
-    random() {
+    static random() {
         const a = randint(-10, 0);
         const b = doWhile(() => randint(0, 10), (x) => Math.abs(x - a) < 5);
         return new Spline(new IntervalNode(a.toTree(), b.toTree(), ClosureType.FF));
     }
+    static getAdequatePoints(nbOfPoints = 4) {
+        let xSolutions = [];
+        const nb = nbOfPoints;
+        // const nb = 2;
+        for (let i = 0; i < nb; i++) {
+            xSolutions.push(randint(-9, 10, xSolutions));
+        }
+        xSolutions.sort((a, b) => a - b);
+        const yValue = randint(-5, 6);
+        const splinePoints = [];
+        let prevYWasAbove = coinFlip();
+        if (coinFlip()) {
+            const y = prevYWasAbove ? randint(-2, 0) : randint(1, 3);
+            prevYWasAbove = y > 0;
+            splinePoints.push([xSolutions[0] - (1 + Math.random() * 3), yValue + y]);
+        }
+        for (let i = 0; i < xSolutions.length; i++) {
+            splinePoints.push([xSolutions[i], yValue]);
+            if (i < xSolutions.length - 1) {
+                const mid = (xSolutions[i] + xSolutions[i + 1]) / 2;
+                const distance = xSolutions[i + 1] - xSolutions[i];
+                const x = mid + ((Math.random() * 2) / 5) * (distance / 2);
+                const y = prevYWasAbove ? randint(-2, 0) : randint(1, 3);
+                prevYWasAbove = y > 0;
+                splinePoints.push([x, yValue + y]);
+            }
+        }
+        if (coinFlip() || splinePoints.length < 4) {
+            const y = prevYWasAbove ? randint(-2, 0) : randint(1, 3);
+            prevYWasAbove = y > 0;
+            splinePoints.push([
+                xSolutions[xSolutions.length - 1] + (1 + Math.random() * 3),
+                yValue + y,
+            ]);
+        }
+        return splinePoints;
+    }
 }
 export class Spline {
     points;

package/lib/index.d.ts

@@ -900,6 +900,9 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     coeffs: number[];
     initTable: string[][];
+}, {}> | Exercise<{
+    points: number[][];
+    initTable: string[][];
 }, {}> | Exercise<{
     k: number;
 }, {}> | Exercise<{
@@ -1681,6 +1684,8 @@ declare const mathExercises: (Exercise<{
     price: number;
     evolution: number;
     askingFinalPrice: boolean;
+}, {}> | Exercise<{
+    evolutions: number[];
 }, {}> | Exercise<{
     initialCapital: number;
     rate: number;
@@ -1694,6 +1699,9 @@ declare const mathExercises: (Exercise<{
 }, {
     withFormula?: boolean;
 }> | Exercise<{
+    x: number;
+    y: number;
+}, {}> | Exercise<{
     int: number;
     power: number;
 }, {}> | Exercise<{

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.87",
+  "version": "3.0.88",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [