math-exercises 3.0.170 → 3.0.171

package/lib/exercises/math/functions/trinoms/problems/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./swedishFlag.js";
 export * from "./maxSurfaceForGivenClosure.js";
+export * from "./rectangleSizesFromPerimeterAndArea.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/trinoms/problems/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/problems/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/problems/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yCAAyC,CAAC"}

package/lib/exercises/math/functions/trinoms/problems/index.js

@@ -1,2 +1,3 @@
 export * from "./swedishFlag.js";
 export * from "./maxSurfaceForGivenClosure.js";
+export * from "./rectangleSizesFromPerimeterAndArea.js";

package/lib/exercises/math/functions/trinoms/problems/rectangleSizesFromPerimeterAndArea.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    perimeterIds: NodeIdentifiers;
+    areaIds: NodeIdentifiers;
+};
+export declare const rectangleSizesFromPerimeterAndArea: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=rectangleSizesFromPerimeterAndArea.d.ts.map

package/lib/exercises/math/functions/trinoms/problems/rectangleSizesFromPerimeterAndArea.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rectangleSizesFromPerimeterAndArea.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/problems/rectangleSizesFromPerimeterAndArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAC;AAqMF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAqBpE,CAAC"}

package/lib/exercises/math/functions/trinoms/problems/rectangleSizesFromPerimeterAndArea.js

@@ -0,0 +1,202 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { sqrt } from "../../../../../tree/nodes/functions/sqrtNode.js";
+import { reifyAlgebraic, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { valueParser } from "../../../../../tree/parsers/valueParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const a = randint(1, 10);
+        const b = randint(a + 1, a + 10);
+        tryToAddWrongProp(propositions, `${a}\\text{ et }${b}`);
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { areaIds, perimeterIds } = identifiers;
+    const area = reifyAlgebraic(areaIds);
+    const perimeter = reifyAlgebraic(perimeterIds);
+    const halfPerimeter = frac(perimeter, 2);
+    const yByX = substract(halfPerimeter, "x");
+    const a = (-1).toTree();
+    const b = halfPerimeter;
+    const c = opposite(area);
+    const delta = substract(square(b), multiply(4, multiply(a, c))).simplify();
+    const x1 = frac(substract(opposite(b), sqrt(delta)), multiply(2, a)).simplify();
+    const x = x1;
+    const y = yByX.toDetailedEvaluation({ x: x }).simplify();
+    const ordered = x.evaluate() < y.evaluate() ? [x, y] : [y, x];
+    return `${ordered[0].toTex()}\\text{ et }${ordered[1].toTex()}`;
+};
+const getInstruction = (identifiers) => {
+    const { areaIds, perimeterIds } = identifiers;
+    const area = reifyAlgebraic(areaIds);
+    const perimeter = reifyAlgebraic(perimeterIds);
+    return `On considère un rectangle de périmètre $${perimeter.toTex()}$ et d'aire $${area.toTex()}$.
+    
+Déterminer la longueur et la largeur de ce rectangle.`;
+};
+const getHint = () => {
+    return `Nomme $x$ et $y$ la longueur et la largeur du rectangle. 
+
+À l'aide du périmètre et de l'aire du rectangle, cela te donnera deux équations d'inconnues $x$ et $y$.
+  
+Utilise l'une des équations pour écrire $y$ en fonction de $x$. 
+
+Puis, réécris l'autre équation en utilisant ce résultat. 
+
+Tu obtiendras alors une équation du second degré, que tu peux résoudre en utilisant le discriminant.`;
+};
+const getCorrection = (identifiers) => {
+    const { areaIds, perimeterIds } = identifiers;
+    const perimeter = reifyAlgebraic(perimeterIds);
+    const halfPerimeter = frac(perimeter, 2).simplify();
+    const area = reifyAlgebraic(areaIds);
+    const yByX = substract(halfPerimeter, "x");
+    const a = (-1).toTree();
+    const b = halfPerimeter;
+    const c = opposite(area);
+    const delta = substract(square(b), multiply(4, multiply(a, c))).simplify();
+    const x1 = frac(substract(opposite(b), sqrt(delta)), multiply(2, a)).simplify();
+    const x2 = frac(add(opposite(b), sqrt(delta)), multiply(2, a)).simplify();
+    const x = x1;
+    const y = yByX.toDetailedEvaluation({ x: x }).simplify();
+    const oredered = x.evaluate() < y.evaluate() ? [x, y] : [y, x];
+    return `On note $x$ et $y$ les dimensions du rectangle.  On a alors : 
+      
+$$
+2x+2y = ${perimeter.toTex()}
+$$
+
+d'où
+
+$$
+x+y = ${halfPerimeter.toTex()}
+$$
+
+et
+
+
+$$
+xy = ${area.toTex()}
+$$
+
+La première équation permet d'exprimer $y$ en fonction de $x$ :
+
+$$
+y = ${halfPerimeter.toTex()} - x
+$$
+
+On injecte cela dans la deuxième équation : 
+
+$$
+${multiply("x", yByX).toTex()} = ${area.toTex()}
+$$
+
+Cela nous donne une équation du second degré : 
+
+$$
+${substract(multiply("x", yByX), area)
+        .simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    })
+        .toTex()}=0
+$$
+
+On calcule le discriminant : 
+
+$$
+\\Delta = ${substract(square(b), multiply(4, multiply(a, c))).toSimplificationTex()}
+$$
+
+Il y a donc deux solutions : 
+
+$$
+x_1 = ${frac(substract(opposite(b), sqrt(delta)), multiply(2, a)).toSimplificationTex()}
+$$
+
+ce qui donne $y = ${yByX
+        .toDetailedEvaluation({ x: x1 })
+        .toSimplificationTex()}$ ; et :
+
+$$
+x_2 = ${frac(add(opposite(b), sqrt(delta)), multiply(2, a)).toSimplificationTex()}
+$$
+
+ce qui donne $y = ${yByX
+        .toDetailedEvaluation({ x: x2 })
+        .toSimplificationTex()}$.
+
+La largeur du rectangle est donc $${oredered[0].toTex()}$ et sa longueur est $${oredered[1].toTex()}$.
+`;
+};
+const getKeys = () => {
+    return ["et"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const answerValues = answer.split("\\text{ et }");
+        const values = ans.includes("et")
+            ? ans.split("\\text{ et }")
+            : ans.split(",");
+        const parsed = values.map((e) => valueParser(e));
+        if (parsed.some((e) => e === false))
+            return false;
+        return [...parsed]
+            .sort((a, b) => a - b)
+            .every((e, i) => numberVEA(e.frenchify(), answerValues[i]));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRectangleSizesFromPerimeterAndAreaQuestion = () => {
+    const largeur = randint(1, 10);
+    const longueur = randint(largeur + 1, largeur + 10);
+    const identifiers = {
+        perimeterIds: add(2 * longueur, 2 * largeur)
+            .simplify()
+            .toIdentifiers(),
+        areaIds: multiply(longueur, largeur).simplify().toIdentifiers(),
+    };
+    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 rectangleSizesFromPerimeterAndArea = {
+    id: "rectangleSizesFromPerimeterAndArea",
+    label: "Déterminer les dimensions d'un rectangle dont on connaît le périmètre et l'aire (second degré)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRectangleSizesFromPerimeterAndAreaQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductIdentities.js

@@ -108,7 +108,7 @@ const getCorrection = (identifiers) => {
                 ["=", substract(square(normU), square(normV)).toTex()],
                 ["=", getAnswer(identifiers)],
             ];
-    return `On utilies une identité remarquable, ainsi que le fait que pour tout vecteur $\\overrightarrow{u}$ : 
+    return `On utilise une identité remarquable, ainsi que le fait que pour tout vecteur $\\overrightarrow{u}$ : 
   
 $$
 \\overrightarrow{u}^2 = \\lVert \\overrightarrow{u} \\rVert^2

package/lib/exercises/math/probaStat/randomVariable/calculateProbaFromVATableLaw.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+import { IntervalNodeIdentifiers } from "../../../../tree/nodes/sets/intervalNode.js";
+type Identifiers = {
+    valuesIds: NodeIdentifiers[];
+    probasIds: NodeIdentifiers[];
+    intervalIds: IntervalNodeIdentifiers;
+};
+export declare const calculateProbaFromVATableLaw: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=calculateProbaFromVATableLaw.d.ts.map

package/lib/exercises/math/probaStat/randomVariable/calculateProbaFromVATableLaw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateProbaFromVATableLaw.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/calculateProbaFromVATableLaw.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,OAAO,EAGL,uBAAuB,EACxB,MAAM,uCAAuC,CAAC;AAQ/C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,WAAW,EAAE,uBAAuB,CAAC;CACtC,CAAC;AAoPF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAsB9D,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/calculateProbaFromVATableLaw.js

@@ -0,0 +1,232 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../tree/nodes/numbers/infiniteNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode, IntervalNodeConstructor, } from "../../../../tree/nodes/sets/intervalNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getPropositions = (n, { answer, probasIds }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const probas = probasIds.map((e) => reifyAlgebraic(e));
+    propWhile(propositions, n, () => {
+        const a = randint(0, 4);
+        const b = randint(a + 1, 5);
+        tryToAddWrongProp(propositions, probas
+            .slice(a, b)
+            .reduce((acc, curr) => add(acc, curr))
+            .simplify()
+            .toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { probasIds, valuesIds } = identifiers;
+    const probas = probasIds.map((e) => reifyAlgebraic(e));
+    const values = valuesIds.map((e) => reifyAlgebraic(e));
+    const interval = IntervalNodeConstructor.fromIdentifiers(identifiers.intervalIds);
+    const aIndex = values.findIndex((v) => v.evaluate() === interval.a.evaluate());
+    const bIndex = values.findIndex((v) => v.evaluate() === interval.b.evaluate());
+    const aIncluded = interval.isLeftClosed();
+    const bIncluded = interval.isRightClosed();
+    if (aIndex > -1 && bIndex > -1) {
+        return probas
+            .slice(aIncluded ? aIndex : aIndex + 1, bIncluded ? bIndex + 1 : bIndex)
+            .reduce((acc, curr) => add(acc, curr))
+            .simplify()
+            .toTex();
+    }
+    else if (aIndex > -1) {
+        return probas
+            .slice(aIncluded ? aIndex : aIndex + 1)
+            .reduce((acc, curr) => add(acc, curr))
+            .simplify()
+            .toTex();
+    }
+    else {
+        return probas
+            .slice(0, bIncluded ? bIndex + 1 : bIndex)
+            .reduce((acc, curr) => add(acc, curr))
+            .simplify()
+            .toTex();
+    }
+};
+const getInstruction = (identifiers) => {
+    const { probasIds, valuesIds } = identifiers;
+    const probas = probasIds.map((e) => reifyAlgebraic(e));
+    const values = valuesIds.map((e) => reifyAlgebraic(e));
+    const interval = IntervalNodeConstructor.fromIdentifiers(identifiers.intervalIds);
+    const inequality = interval.toInequality("X".toTree());
+    return `Soit $X$ une variable aléatoire dont la loi de probabilité est donnée ci-dessous.
+  
+${mdTable([
+        ["$x_i$", ...values.map((e) => dollarize(e.toTex()))],
+        ["$P(X=x_i)$", ...probas.map((e) => dollarize(e.toTex()))],
+    ])}
+
+Calculer $P\\left(${inequality.toTex()}\\right)$.
+`;
+};
+const getHint = (identifiers) => {
+    const { intervalIds } = identifiers;
+    const interval = IntervalNodeConstructor.fromIdentifiers(intervalIds);
+    const inequality = interval.toInequality("X".toTree());
+    return `Repère les valeurs $x_i$ de $X$ qui vérifient l'inégalité $${inequality.toTex()}$.
+  
+Puis, additionne les probabilités correspondantes.`;
+};
+const getCorrection = (identifiers) => {
+    const { probasIds, valuesIds } = identifiers;
+    const probas = probasIds.map((e) => reifyAlgebraic(e));
+    const values = valuesIds.map((e) => reifyAlgebraic(e));
+    const interval = IntervalNodeConstructor.fromIdentifiers(identifiers.intervalIds);
+    const inequality = interval.toInequality("X".toTree());
+    const aIndex = values.findIndex((v) => v.evaluate() === interval.a.evaluate());
+    const bIndex = values.findIndex((v) => v.evaluate() === interval.b.evaluate());
+    const aIncluded = interval.isLeftClosed();
+    const bIncluded = interval.isRightClosed();
+    let plage = [];
+    if (aIndex > -1 && bIndex > -1) {
+        plage = [aIncluded ? aIndex : aIndex + 1, bIncluded ? bIndex + 1 : bIndex];
+    }
+    else if (aIndex > -1) {
+        plage = [aIncluded ? aIndex : aIndex + 1, 5];
+    }
+    else {
+        plage = [0, bIncluded ? bIndex + 1 : bIndex];
+    }
+    return `On repère les valeurs $x_i$ de $X$ qui vérifient l'inégalité $${inequality.toTex()}$. Ce sont : 
+  
+$$
+${values
+        .slice(plage[0], plage[1])
+        .map((e) => e.toTex())
+        .join("\\ ; \\ ")}
+$$
+
+Puis, on additionne les probabilités correspondantes : 
+
+${alignTex([
+        ["", `P\\left(${inequality.toTex()}\\right)`],
+        [
+            "=",
+            probas
+                .slice(plage[0], plage[1])
+                .reduce((acc, curr) => add(acc, curr))
+                .toTex(),
+        ],
+        ["=", getAnswer(identifiers)],
+    ])}
+
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+function generateNumbers(n) {
+    const total = 1000;
+    let remaining = total;
+    let parts = [];
+    for (let i = 0; i < n - 1; i++) {
+        const max = remaining - (n - i - 1);
+        const value = Math.floor(Math.random() * max) + 1;
+        parts.push(value);
+        remaining -= value;
+    }
+    parts.push(remaining);
+    parts = shuffle(parts);
+    return parts.map((v) => v / total);
+}
+const getCalculateProbaFromVaTableLawQuestion = () => {
+    const values = randTupleInt(5, {
+        from: -9,
+        to: 10,
+        allDifferent: true,
+        sorted: true,
+    });
+    //types : 0 : >a, 1 : a<=X<=b, 2 : <b
+    const type = randint(0, 3);
+    let a;
+    let b;
+    let intervalIds;
+    switch (type) {
+        case 0:
+            a = random([values[1], values[2]]);
+            intervalIds = new IntervalNode(a.toTree(), PlusInfinityNode, random([ClosureType.OF, ClosureType.OO])).toIdentifiers();
+            break;
+        case 1:
+            a = values[1];
+            b = values[4];
+            intervalIds = new IntervalNode(a.toTree(), b.toTree(), random([
+                ClosureType.OF,
+                ClosureType.OO,
+                ClosureType.FF,
+                ClosureType.FO,
+            ])).toIdentifiers();
+            break;
+        case 2:
+        default:
+            b = random([values[2], values[3]]);
+            intervalIds = new IntervalNode(MinusInfinityNode, b.toTree(), random([ClosureType.FO, ClosureType.OO])).toIdentifiers();
+            break;
+    }
+    const identifiers = {
+        valuesIds: values.map((e) => e.toTree().toIdentifiers()),
+        intervalIds,
+        probasIds: generateNumbers(5).map((e) => e.toTree().toIdentifiers()),
+    };
+    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),
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: false,
+            },
+        },
+    };
+};
+export const calculateProbaFromVATableLaw = {
+    id: "calculateProbaFromVATableLaw",
+    connector: "=",
+    label: "Calculer une probabilité du type $P(a\\leq X\\leq b)$ avec une loi de probabilité",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCalculateProbaFromVaTableLawQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -3,4 +3,5 @@ export * from "./randomVariableVariance.js";
 export * from "./isTableProbabilityLaw.js";
 export * from "./randomVariableStandardDeviation.js";
 export * from "./findValueToMatchRandomVariableAverage.js";
+export * from "./calculateProbaFromVATableLaw.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AAErD,cAAc,4CAA4C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AAErD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,mCAAmC,CAAC"}

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

@@ -4,3 +4,4 @@ export * from "./isTableProbabilityLaw.js";
 export * from "./randomVariableStandardDeviation.js";
 // export * from "./findValueForFairRandomVariable.js";
 export * from "./findValueToMatchRandomVariableAverage.js";
+export * from "./calculateProbaFromVATableLaw.js";

package/lib/exercises/math/sequences/arithmetic/arithmeticVariations.js

@@ -150,7 +150,7 @@ export const arithmeticVariations = {
     answerType: "QCU",
     options,
     validateOptions: (opts) => {
-        return opts.forms.length > 0
+        return opts?.forms?.length > 0
             ? {
                 message: "OK",
                 valid: true,

package/lib/index.d.ts

@@ -1545,6 +1545,9 @@ declare const mathExercises: (Exercise<{
 }, {
     askedParam: string[];
 }> | Exercise<{
+    perimeterIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    areaIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     k: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -2995,6 +2998,10 @@ declare const mathExercises: (Exercise<{
     valuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     probasIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     avgIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    valuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    probasIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    intervalIds: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     pA: number;
     pB: 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/math/geometry/point.js

@@ -143,8 +143,8 @@ export class Point {
         return Math.sqrt(dx ** 2 + dy ** 2);
     }
     distanceToNode(B) {
-        const dx = substract(this.x, B.x);
-        const dy = substract(this.y, B.y);
+        const dx = substract(B.x, this.x);
+        const dy = substract(B.y, this.y);
         return sqrt(add(square(dx), square(dy)));
     }
     equals(B) {

package/lib/math/utils/random/randTupleInt.d.ts

@@ -3,6 +3,7 @@ interface RandTupleIntOptions {
     to?: number;
     excludes?: number[][];
     allDifferent?: boolean;
+    sorted?: boolean;
 }
 /**
  * @param size tuple length

package/lib/math/utils/random/randTupleInt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"randTupleInt.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/random/randTupleInt.ts"],"names":[],"mappings":"AAGA,UAAU,mBAAmB;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,GACvB,MAAM,MAAM,EACZ,SAAS,mBAAmB,KAC3B,MAAM,EAuBR,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,IAAI,MAAM,EACV,MAAM,MAAM,EACZ,SAAS,mBAAmB,KAC3B,MAAM,EAAE,EAcV,CAAC"}
+{"version":3,"file":"randTupleInt.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/random/randTupleInt.ts"],"names":[],"mappings":"AAGA,UAAU,mBAAmB;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,GACvB,MAAM,MAAM,EACZ,SAAS,mBAAmB,KAC3B,MAAM,EAyBR,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,IAAI,MAAM,EACV,MAAM,MAAM,EACZ,SAAS,mBAAmB,KAC3B,MAAM,EAAE,EAcV,CAAC"}

package/lib/math/utils/random/randTupleInt.js

@@ -26,6 +26,9 @@ export const randTupleInt = (size, options) => {
         }
     } while (options?.excludes &&
         options.excludes.some((el) => arrayEqual(el, res)));
+    if (options?.sorted) {
+        return res.sort((a, b) => a - b);
+    }
     return res;
 };
 export const distinctRandTupleInt = (nb, size, options) => {

package/package.json

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