math-exercises 3.0.94 → 3.0.96

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

@@ -9,3 +9,4 @@ export * from "./powersProduct.js";
 export * from "./scientificToDecimal.js";
 export * from "./powersMixOperations.js";
 export * from "./powersOfTenMixOperations.js";
+export * from "./powerNotation.js";

package/lib/exercises/math/powers/powerNotation.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    n: number;
+    isSimplified: boolean;
+};
+export declare const powerNotation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=powerNotation.d.ts.map

package/lib/exercises/math/powers/powerNotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"powerNotation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powerNotation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAmIF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAkB/C,CAAC"}

package/lib/exercises/math/powers/powerNotation.js

@@ -0,0 +1,126 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.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 { isPowerNode, power } from "../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (nn, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { a, n } = identifiers;
+    // Soit 1/a^n
+    // (a+1)^n
+    tryToAddWrongProp(propositions, power(add(a, 1).simplify(), n).toTex());
+    // (a-1)^n
+    tryToAddWrongProp(propositions, power(substract(a, 1).simplify(), n).toTex());
+    // -a^n
+    tryToAddWrongProp(propositions, power(multiply(-1, a), n).toTex());
+    // -a^(-n)
+    tryToAddWrongProp(propositions, power(multiply(-1, a), multiply(-1, n)).toTex());
+    // a*-1^(-n)
+    tryToAddWrongProp(propositions, multiply(a, power(-1, multiply(-1, n))).toTex());
+    // n^a
+    tryToAddWrongProp(propositions, power(n, a).toTex());
+    // -n^a
+    tryToAddWrongProp(propositions, power(multiply(-1, n), a).toTex());
+    // n^(-a)
+    tryToAddWrongProp(propositions, power(n, multiply(-1, a)).toTex());
+    return shuffleProps(propositions, nn);
+};
+const getAnswer = (identifiers) => {
+    // (1/a^n) <=> a^(-n)
+    const { a, n } = identifiers;
+    return `${power(a, multiply(-1, n)).toTex()}`;
+};
+const getInstruction = (identifiers) => {
+    const { a, n, isSimplified } = identifiers;
+    const an = power(a, n);
+    const fraction = frac(1, isSimplified ? an.evaluate() : an);
+    return `Écrire $${fraction.toTex()}$ sous la forme $a^n$, avec $n \\in \\mathbb{Z}.$`;
+};
+const getHint = (identifiers) => {
+    const fracForm = frac(1, power("a", "n")).toTex();
+    return `On a : 
+  
+$$
+${fracForm} = ${power("a", multiply(-1, "n")).toTex()}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, n, isSimplified } = identifiers;
+    const fraction = frac(1, power(a, n));
+    const fracForm = frac(1, power("a", "n")).toTex();
+    return `On sait que : 
+  
+$$
+${fracForm} = ${power("a", multiply(-1, "n")).toTex()}
+$$
+
+Ici on a donc :
+
+$$
+${fraction.toTex()} = ${power(a, multiply(-1, n)).toTex()}
+$$
+
+avec $a = ${a}$ et $n = ${n}$${isSimplified
+        ? `, sachant que $${power(a, n).evaluate()} = ${power(a, n).toTex()}$`
+        : ""}.`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { a, n } = identifiers;
+    const node = parseAlgebraic(ans);
+    try {
+        return (isPowerNode(node) &&
+            node.simplify().equals(power(a, multiply(-1, n)).simplify()));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPowerNotationQuestion = (ops) => {
+    const isSimplePower = (a, n) => {
+        return (n === 2 && a <= 11) || (n === 3 && a <= 3);
+    };
+    const a = randint(2, 12);
+    const n = randint(2, 5);
+    const isSimplified = isSimplePower(a, n) ? coinFlip() : false;
+    const identifiers = { a, n, isSimplified };
+    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 powerNotation = {
+    id: "powerNotation",
+    label: "Écrire une fraction sous la forme $a^n$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPowerNotationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: false,
+};

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

@@ -1 +1 @@
-{"version":3,"file":"averageList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/averageList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA2FF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAe7C,CAAC"}
+{"version":3,"file":"averageList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/averageList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA2FF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAgB7C,CAAC"}

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

@@ -91,4 +91,5 @@ export const averageList = {
     subject: "Mathématiques",
     hasHintAndCorrection: true,
     getQuestionFromIdentifiers,
+    shouldHaveCalculator: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"averageWithTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/averageWithTable.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,QAAQ,EAaT,MAAM,sBAAsB,CAAC;AAQ9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAoHF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAgBlD,CAAC"}
+{"version":3,"file":"averageWithTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/averageWithTable.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,QAAQ,EAaT,MAAM,sBAAsB,CAAC;AAQ9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAoHF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAiBlD,CAAC"}

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

@@ -103,4 +103,5 @@ export const averageWithTable = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"calculateMeanFromFrequencies.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/calculateMeanFromFrequencies.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAwGF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAoB9D,CAAC"}
+{"version":3,"file":"calculateMeanFromFrequencies.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/calculateMeanFromFrequencies.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAwGF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAqB9D,CAAC"}

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

@@ -105,4 +105,5 @@ export const calculateMeanFromFrequencies = {
     getAnswer,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"standardDeviationList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/standardDeviationList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA6HF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}
+{"version":3,"file":"standardDeviationList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/standardDeviationList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA6HF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAevD,CAAC"}

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

@@ -125,4 +125,5 @@ export const standardDeviationList = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"standardDeviationTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/standardDeviationTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAkJF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"standardDeviationTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/standardDeviationTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAkJF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

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

@@ -141,4 +141,5 @@ export const standardDeviationTable = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
 };

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

@@ -2,4 +2,5 @@ export * from "./intervals/index.js";
 export * from "./setBelonging.js";
 export * from "./nameOfNumberSets.js";
 export * from "./subsetsOfKnownSets.js";
+export * from "./isNumberDecimal.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC"}

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

@@ -2,3 +2,4 @@ export * from "./intervals/index.js";
 export * from "./setBelonging.js";
 export * from "./nameOfNumberSets.js";
 export * from "./subsetsOfKnownSets.js";
+export * from "./isNumberDecimal.js";

package/lib/exercises/math/sets/isNumberDecimal.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    options: {
+        a: NodeIdentifiers;
+        isDecimal: boolean;
+    }[];
+};
+export declare const isNumberdecimal: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=isNumberDecimal.d.ts.map

package/lib/exercises/math/sets/isNumberDecimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNumberDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/isNumberDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAa7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE;QACP,CAAC,EAAE,eAAe,CAAC;QACnB,SAAS,EAAE,OAAO,CAAC;KACpB,EAAE,CAAC;CACL,CAAC;AAqIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAmBjD,CAAC"}

package/lib/exercises/math/sets/isNumberDecimal.js

@@ -0,0 +1,144 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../math/numbers/rationals/rational.js";
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../tree/nodes/nodeConstructor.js";
+import { isConstantNode } from "../../../tree/nodes/numbers/constantNode.js";
+import { PiNode } from "../../../tree/nodes/numbers/piNode.js";
+import { isFractionNode, } from "../../../tree/nodes/operators/fractionNode.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { random } from "../../../utils/alea/random.js";
+import { doWhile } from "../../../utils/doWhile.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, options }) => {
+    const propositions = [];
+    for (const { a, isDecimal } of options) {
+        const prop = reifyAlgebraic(a).toTex();
+        if (isDecimal) {
+            addValidProp(propositions, prop);
+        }
+        else {
+            tryToAddWrongProp(propositions, prop);
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return "";
+};
+const getInstruction = (identifiers) => {
+    return "Parmi ces nombres, lesquels sont décimaux ?";
+};
+const getHint = (identifiers) => {
+    return "Un nombre est décimal s'il a un nombre fini de chiffres après la virgule.";
+};
+const getCorrection = (identifiers) => {
+    const { options } = identifiers;
+    let correction = "";
+    for (const { a, isDecimal } of options) {
+        const node = reifyAlgebraic(a);
+        const tex = node.toTex();
+        if (isConstantNode(node)) {
+            correction += `- $${tex}$ n'est pas un nombre décimal, car il s'écrit avec un nombre infini de chiffres après la virgule.\n\n`;
+        }
+        else if (isFractionNode(node)) {
+            const denom = node.rightChild.toTex();
+            if (isDecimal) {
+                correction += `- $${tex} = ${node
+                    .evaluate()
+                    .frenchify()}$ est un nombre décimal car il s'écrit avec un nombre fini de chiffres après la virgule.\n\n`;
+            }
+            else {
+                correction += `- $${tex} \\approx ${node
+                    .evaluate()
+                    .frenchify()
+                    .slice(0, 8)}\\ldots$ n'est pas un nombre décimal, car il s'écrit avec un nombre infini de chiffres après la virgule.\n\n`;
+            }
+        }
+        else {
+            if (isDecimal) {
+                correction += `- $${tex}$ est un nombre décimal car il a un nombre fini de chiffres après sa virgule.\n\n`;
+            }
+            else {
+                correction += `- $${tex}$ est un nombre décimal car c'est un nombre entier. En effet, on peut écrire $${tex} = ${tex},0$.\n\n`;
+            }
+        }
+    }
+    return correction;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const generateNonDecimalNumber = () => {
+    const nonDecimals = [];
+    nonDecimals.push(RationalConstructor.randomPureRational().toTree());
+    nonDecimals.push(PiNode);
+    return random(nonDecimals);
+};
+const generateDecimalNumber = () => {
+    const decimals = [];
+    decimals.push(randint(0, 100).toTree());
+    decimals.push(randfloat(0, 100, 2).toTree());
+    decimals.push(RationalConstructor.randomDecimal().toTree());
+    return random(decimals);
+};
+const getIsNumberdecimalQuestion = (ops) => {
+    let choices = [];
+    const decimal = generateDecimalNumber();
+    const nonDecimal = generateNonDecimalNumber();
+    choices.push({ a: decimal, isDecimal: true });
+    choices.push({ a: nonDecimal, isDecimal: false });
+    for (let i = 0; i < 2; i++) {
+        const isDecimal = coinFlip();
+        const randomNumber = doWhile(() => (isDecimal ? generateDecimalNumber() : generateNonDecimalNumber()), (a) => choices.some((c) => c.a.toTex() === a.toTex()));
+        choices.push({ a: randomNumber, isDecimal });
+    }
+    const identifiers = {
+        options: choices.map((c) => {
+            return {
+                a: c.a.toIdentifiers(),
+                isDecimal: c.isDecimal,
+            };
+        }),
+    };
+    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 isNumberdecimal = {
+    id: "isNumberDecimal",
+    label: "Dire si un nombre est décimal",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsNumberdecimalQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};

package/lib/index.d.ts

@@ -39,22 +39,6 @@ declare const mathExercises: (Exercise<{
     isAskingParity: boolean;
 }, {}> | Exercise<{
     n: number;
-}, {}> | Exercise<{
-    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-}, {}> | Exercise<{
-    options: {
-        a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-        isDecimal: boolean;
-    }[];
-}, {}> | Exercise<{
-    x: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    y: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-}, {}> | Exercise<{
-    x: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    y: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-}, {}> | Exercise<{
-    point: import("./math/geometry/point.js").PointIdentifiers;
-    func: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, {}> | Exercise<{
     n: number;
     threshold: number;
@@ -62,22 +46,6 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-}, {}> | Exercise<{
-    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    isMinusInside: boolean;
-}, {}> | Exercise<{
-    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-}, {}> | Exercise<{
-    point: import("./math/geometry/point.js").PointIdentifiers;
-    bounding: number;
-}, {}> | Exercise<{
-    type: number;
-    a: number;
-    b?: number;
-    c?: number;
-    d?: number;
 }, {}> | Exercise<{
     integerFirst: boolean;
     integer: number;
@@ -153,10 +121,6 @@ declare const mathExercises: (Exercise<{
 }, {
     allowNonIrreductible?: boolean;
 }> | Exercise<{
-    a: number;
-    n: number;
-    isSimplified: boolean;
-}, {}> | Exercise<{
     a: number;
     b: number;
     c: number;
@@ -301,6 +265,9 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     dec: number;
     pow: number;
+}, {}> | Exercise<{
+    point: import("./math/geometry/point.js").PointIdentifiers;
+    bounding: number;
 }, {}> | Exercise<{
     choices: {
         node: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
@@ -932,6 +899,21 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     points: number[][];
     initTable: string[][];
+}, {}> | Exercise<{
+    point: import("./math/geometry/point.js").PointIdentifiers;
+    func: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    type: number;
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+}, {}> | Exercise<{
+    type: number;
+    a: number;
+    b?: number;
+    c?: number;
+    d?: number;
 }, {}> | Exercise<{
     k: number;
 }, {}> | Exercise<{
@@ -939,6 +921,9 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     a: number;
     b: number;
+}, {}> | Exercise<{
+    x: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    y: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, {}> | Exercise<{
     a: number;
     b: number;
@@ -1102,6 +1087,9 @@ declare const mathExercises: (Exercise<{
     type: number;
 }, {}> | Exercise<{
     a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, {}> | Exercise<{
     lowerBound: number;
     upperBound: number;
@@ -1174,7 +1162,9 @@ declare const mathExercises: (Exercise<{
     xs: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     type: number;
     ineqSymbol?: string;
-}, {}> | Exercise<{
+}, {
+    questionType: string;
+}> | Exercise<{
     initTable: string[][];
     a: number;
     x1: number;
@@ -1211,6 +1201,8 @@ declare const mathExercises: (Exercise<{
     b?: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, {}> | Exercise<{
     x: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, {}> | Exercise<{
     coin: boolean;
     radius: number;
@@ -1837,6 +1829,10 @@ declare const mathExercises: (Exercise<{
     b: number;
     c: number;
     d: number;
+}, {}> | Exercise<{
+    a: number;
+    n: number;
+    isSimplified: boolean;
 }, {}> | Exercise<{
     c: number;
 }, {}> | Exercise<{
@@ -2232,6 +2228,11 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     subset: number;
     set: number;
+}, {}> | Exercise<{
+    options: {
+        a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+        isDecimal: boolean;
+    }[];
 }, {}> | Exercise<{
     x: number;
     y: number;
@@ -2452,11 +2453,6 @@ declare const mathExercises: (Exercise<{
     labels: string[];
 }, {}>)[];
 declare const pcExercises: (Exercise<{
-    atomicMass: number;
-    atomicNumber: number;
-    isAsking: string;
-    symbol: string;
-}, {}> | Exercise<{
     numbers: number[];
 }, {}> | Exercise<{
     randQuation: number;
@@ -2611,6 +2607,11 @@ declare const pcExercises: (Exercise<{
     randomMaterial1: number;
     randomMaterial2: number;
     ramdonAngleIncidenceDeg: number;
+}, {}> | Exercise<{
+    atomicMass: number;
+    atomicNumber: number;
+    isAsking: string;
+    symbol: string;
 }, {}> | Exercise<{
     isAsking: string;
     enetringLightX: 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/package.json

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