math-exercises 3.0.190 → 3.0.192

package/lib/exercises/math/sequences/geometric/geometricFindRecurrenceFormula.js

@@ -0,0 +1,186 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../exercises/options/optionFirstTermRankOne.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { NodeRewriter } from "../../../../tree/utilities/nodeRewriter.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { firstValue, reason } = identifiers;
+    return `$(u_n)$ est une suite géométrique de premier terme $u_{${firstRank}} = ${firstValue}$ et de raison $q = ${reason}$. 
+  
+Donner la relation de récurrence de $(u_n)$.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { reason } = identifiers;
+    const nodeFormula = multiply(new VariableNode("u_{n}"), reason);
+    const equalNode = new EqualNode(new VariableNode("u_{n+1}"), nodeFormula);
+    return equalNode;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Quelle est la formule qui relie deux termes consécutifs d'une suite géométrique ?
+
+$$
+u_{n+1} = ...
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { reason } = identifiers;
+    const answer = getAnswer(identifiers);
+    return `La relation de récurrence d'une suite géométrique de raison $q$ est :
+    
+$$
+u_{n+1} = u_{n} \\ \\times \\ q
+$$
+    
+Ici, puisque $q = ${reason}$, on a : 
+
+$$
+${answer}
+$$`;
+};
+const getPropositions = (n, { answer, reason, firstValue }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //student: no lhs
+    {
+        const texWrong = answer.replace("u_{n+1}=", "");
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //student: geometric -> arithmetic
+    {
+        const nodeFormula = add(new VariableNode("u_{n}"), reason);
+        const texWrong = "u_{n+1}=" + nodeFormula.toTex();
+        tryToAddWrongProp(propositions, texWrong);
+        //student: no lhs
+        {
+            tryToAddWrongProp(propositions, nodeFormula.toTex());
+        }
+    }
+    //student: recurrence formula -> explicit formula
+    {
+        const nodeFormula = multiply(firstValue, power(reason, substract("n".toTree(), firstRank).simplify()));
+        const equalNode = new EqualNode("u_n".toTree(), nodeFormula);
+        tryToAddWrongProp(propositions, equalNode.toTex());
+        if (probaFlip(0.1)) {
+            const equalNode = new EqualNode("u_{n+1}".toTree(), nodeFormula);
+            tryToAddWrongProp(propositions, equalNode.toTex());
+        }
+        //student: no lhs
+        {
+            tryToAddWrongProp(propositions, nodeFormula.toTex());
+        }
+    }
+    if (probaFlip(0.9)) {
+        //student: swap(initial, reason)
+        {
+            const nodeFormula = multiply(firstValue, power(reason, new VariableNode("n")));
+            const texWrong = "u_n=" + nodeFormula.toTex();
+            tryToAddWrongProp(propositions, texWrong);
+        }
+    }
+    else {
+        //student: u_n = u_n * q
+        {
+            const texWrong = answer.replace("u_{n+1}", "u_{n}");
+            tryToAddWrongProp(propositions, texWrong);
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        //TODO faire fonctionner parseAlgebraic("u_n=3+2n") (token _ not implemented)
+        if (!ans.includes("=")) {
+            return false;
+        }
+        // const nodeAns = parseAlgebraic(ans);
+        const nodeAns = (() => {
+            const [lhs, rhs] = ans.split("=");
+            const lhsRefined = lhs.replace("u_{n+1}", "v");
+            const nodeLhs = lhsRefined.toTree();
+            const rhsRefined = rhs.replace("u_n", "u").replace("u_{n}", "u");
+            const nodeRhs = parseAlgebraic(rhsRefined);
+            return new EqualNode(nodeLhs, nodeRhs);
+        })();
+        const nodeAnswer = (() => {
+            const nodeAnswer = getAnswerNode(identifiers);
+            const nodeAnswerRefined = nodeBySubstitutingVar(nodeBySubstitutingVar(nodeAnswer, new VariableNode("v"), new VariableNode("u_{n+1}")), new VariableNode("u"), new VariableNode("u_{n}"));
+            return nodeAnswerRefined;
+        })();
+        const isValidLhs = () => nodeAns.leftChild.toTex() === nodeAnswer.leftChild.toTex();
+        const isValidRhs = () => {
+            const nodeAnsRhs = nodeAns.rightChild;
+            const nodeAnswerRhs = nodeAnswer.rightChild;
+            const isEquivalentFound = () => {
+                const nodeAns = nodeAnsRhs;
+                const nodeAnswer = nodeAnswerRhs;
+                const arrNodeAnswerEquivalent = NodeRewriter.getArrNodeEquivalent(nodeAnswer);
+                return arrNodeAnswerEquivalent.some((nodeAnswerRefined) => {
+                    const isEqual = NodeComparator.isEqualViaFrac(nodeAns, nodeAnswerRefined);
+                    return isEqual;
+                });
+            };
+            return isEquivalentFound();
+        };
+        return isValidLhs() && isValidRhs();
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const getGeometricFindRecurrenceFormulaQuestion = () => {
+    const firstValue = randint(-10, 10, [0]);
+    const reason = randint(-10, 10, [0, 1, firstValue]);
+    const identifiers = { reason, firstValue };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["un", "unplus1", "equal", "n"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const { optsDefaultFirstTermRankOne, generatorOptionFirstTermRankOne } = getOptionFirstTermRankOneStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne);
+const options = [generatorOptionFirstTermRankOne];
+export const geometricFindRecurrenceFormula = {
+    id: "geometricFindRecurrenceFormula",
+    connector: "=",
+    label: "Déterminer la relation de récurrence d'une suite géométrique à partir de la raison et de $u_0$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindRecurrenceFormulaQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/sequences/geometric/graph/geometricPlaceFirstPoints.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsInitial: NodeIdentifiers;
+    nodeIdsReason: NodeIdentifiers;
+    firstRank: number;
+};
+type Options = OptionFirstTermRankOne & {
+    typeSignReason: string[];
+};
+export declare const geometricPlaceFirstPoints: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=geometricPlaceFirstPoints.d.ts.map

package/lib/exercises/math/sequences/geometric/graph/geometricPlaceFirstPoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricPlaceFirstPoints.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/geometricPlaceFirstPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAQ3D,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,CAAC;IAChC,aAAa,EAAE,eAAe,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA0LF,KAAK,OAAO,GAAG,sBAAsB,GAAG;IAAE,cAAc,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAkBrE,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBpE,CAAC"}

package/lib/exercises/math/sequences/geometric/graph/geometricPlaceFirstPoints.js

@@ -0,0 +1,189 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { greenMain } from "../../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { ggbPointToCoords } from "../../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../../geogebra/parsers/parseGGBPoints.js";
+import { Point } from "../../../../../math/geometry/point.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { probaFlip } from "../../../../../utils/alea/probaFlip.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const nbPoints = 4;
+const getInstruction = (identifiers) => {
+    const { firstRank, nodeIdsInitial, nodeIdsReason } = identifiers;
+    const [nodeInitial, nodeReason] = [nodeIdsInitial, nodeIdsReason].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `On considère une suite géométrique $u$ de premier rang $u_{${firstRank}}=${nodeInitial.toTex()}$ et de raison $${nodeReason.toTex()}$.
+Dans le repère ci-dessous, placer les points représentant les $${nbPoints}$ premiers termes de de $u$.`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { firstRank, nodeIdsInitial, nodeIdsReason } = identifiers;
+    const [nodeInitial, nodeReason] = [nodeIdsInitial, nodeIdsReason].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrNodeTerm = [...Array(nbPoints).keys()].map((i) => multiply(nodeInitial, power(nodeReason, i))
+        .simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        distributePowersOnFrac: true,
+    })
+        .simplify({ towardsDistribute: false }));
+    const arrPoint = arrNodeTerm.map((nodeTerm, i) => {
+        const nodeX = (firstRank + i).toTree();
+        return new Point(`P${firstRank + i}`, nodeX, nodeTerm);
+    });
+    return {
+        arrPoint,
+    };
+};
+const getHint = () => {
+    return `Une suite est représentée par un nuage de point. L'abscisse de chaque point est le rang du terme, et l'ordonnée est le terme en lui-même.`;
+};
+const getCorrection = (identifiers) => {
+    const { firstRank, nodeIdsInitial, nodeIdsReason } = identifiers;
+    const [nodeInitial, nodeReason] = [nodeIdsInitial, nodeIdsReason].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const { arrPoint } = getAnswerStuff(identifiers);
+    return `Une suite est représentée par un nuage de point. L'abscisse de chaque point est le rang du terme, et l'ordonnée est le terme en lui-même.
+
+La formule générale de la suite $u$ est : 
+
+$$
+u_{n} = ${nodeInitial.toTex()} \\ \\times \\ (${nodeReason.toTex()})^{${substract(new VariableNode("n"), firstRank)
+        .simplify({ towardsDistribute: true })
+        .toTex()}} 
+$$
+  
+Les points du nuage sont donc ici les suivants : 
+
+${alignTex(arrPoint.map((point, i) => {
+        const rank = firstRank + i;
+        return [`(${rank};u_{${rank}})`, "=", point.toCoords()];
+    }))}
+
+En pratique, on place le premier point. Puis, pour placer le point suivant : 
+  - pour l'abscisse : on se décale d'une unité sur l'axe des abscisses  
+  - pour l'ordonnée : on multiplie l'ordonnée du point précédent par la raison (attention au changement de signe si la raison est négative)
+
+`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { arrPoint } = getAnswerStuff(identifiers);
+    return [
+        ...arrPoint.flatMap((point) => point.toGGBCommand({ color: `${greenMain}`, showLabel: false })),
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { arrPoint } = getAnswerStuff(identifiers);
+    const values = arrPoint.map((point) => point.y.evaluate());
+    const ggb = new GeogebraConstructor({
+        commands: [],
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+    });
+    const yMin = Math.min(...values);
+    const yMax = Math.max(...values);
+    return ggb.getOptions({
+        coords: [-1, 6, Math.min(yMin, 0) - 1, Math.max(yMax, 1) + 1],
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer: _ggbAnswer, ...identifiers }) => {
+    const points = parseGGBPoints(ans)
+        .map((p) => ggbPointToCoords(p))
+        .sort((a, b) => a.x - b.x);
+    const validPoints = getAnswerStuff(identifiers).arrPoint;
+    return points.every((p, i) => Math.abs(p.x - validPoints[i].x.evaluate()) < 0.4 &&
+        Math.abs(p.y - validPoints[i].y.evaluate()) < 0.4);
+};
+const getPlaceFirstSequencePointsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const typeSignReason = opts?.typeSignReason
+        ? random(opts.typeSignReason)
+        : random(optsDefault.typeSignReason);
+    const [nodeInitialAbs, nodeReasonAbs] = random([
+        //increasing
+        [(1).toTree(), (2).toTree()],
+        [(1).toTree(), frac(3, 2)],
+        [(1).toTree(), frac(4, 3)],
+        // [(1).toTree(), frac(5, 3)],
+        [frac(1, 2), (2).toTree()],
+        [frac(1, 2), frac(3, 2)],
+        [frac(1, 3), (3).toTree()],
+        [(2).toTree(), frac(3, 2)],
+        [(2).toTree(), frac(4, 3)],
+        //decreasing
+        [(8).toTree(), frac(1, 2)],
+        [(9).toTree(), frac(1, 3)],
+        [(9).toTree(), frac(2, 3)],
+        [(8).toTree(), frac(3, 4)],
+        // [(10).toTree(), frac(3, 5)],
+    ]);
+    const nodeInitial = (() => {
+        const sign = probaFlip(0.7) ? +1 : -1;
+        return multiply(sign, nodeInitialAbs).simplify({
+            towardsDistribute: true,
+        });
+    })();
+    const nodeReason = (() => {
+        const sign = typeSignReason === "positive" ? +1 : -1;
+        return multiply(sign, nodeReasonAbs).simplify({
+            towardsDistribute: true,
+        });
+    })();
+    const identifiers = {
+        firstRank,
+        nodeIdsInitial: nodeInitial.toIdentifiers(),
+        nodeIdsReason: nodeReason.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+const { optsDefaultFirstTermRankOne, generatorOptionFirstTermRankOne } = getOptionFirstTermRankOneStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne, {
+    typeSignReason: ["positive"],
+});
+const options = [
+    generatorOptionFirstTermRankOne,
+    {
+        id: "typeSignReason",
+        label: "Signe de la raison",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["positive", "négative"],
+        defaultValue: optsDefault.typeSignReason,
+    },
+];
+export const geometricPlaceFirstPoints = {
+    id: "geometricPlaceFirstPoints",
+    label: "Placer les premiers termes d'une suite géométrique dans un repère",
+    isSingleStep: true,
+    generator: (nb, opts) => 
+    // getDistinctQuestions(() => getPlaceFirstSequencePointsQuestion(opts), nb),
+    [...Array(nb).keys()].map(() => getPlaceFirstSequencePointsQuestion(opts)),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    getInstruction,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    options,
+};

package/lib/exercises/math/sequences/geometric/graph/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./geometricPlaceFirstPoints.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/geometric/graph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC"}

package/lib/exercises/math/sequences/geometric/graph/index.js

@@ -0,0 +1 @@
+export * from "./geometricPlaceFirstPoints.js";

package/lib/index.d.ts

@@ -1257,6 +1257,9 @@ declare const mathExercises: (Exercise<{
 }, {
     method: string;
 }> | Exercise<{
+    coeffs: number[];
+    isAskingX: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
@@ -1947,6 +1950,27 @@ declare const mathExercises: (Exercise<{
         a: number;
         k: number;
     }[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    xIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    xIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    yIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    xIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    yIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    xIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    yIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    xIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    yIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    zIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    tIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     affine1Ids: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
     affine2Ids: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
@@ -4364,32 +4388,9 @@ declare const mathExercises: (Exercise<{
     values: number[][];
     caseAsked: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    labels: string[];
-    data: number[];
-    itemAsked: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    isAskingX: boolean;
-    xValue?: number;
-    yValue?: number;
-    a: number;
-    b: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    points: number[][];
-    labels: string[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    quartiles: number[];
-    arrQuartileIndex: (0 | 1 | 2 | 3 | 4)[];
-    typeQ: "below" | "between" | "above";
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    quartileIndex: 0 | 1 | 2 | 3 | 4;
-    quartiles: number[];
+    coeffs: (number | undefined)[][];
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    indexTopic: number;
-    isLess: boolean;
-    arrDistrib: {
-        name: string;
-        indicators: number[];
-    }[];
+    coeffs: (number | undefined)[][];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     barChart: {
         description: string;
@@ -4429,6 +4430,19 @@ declare const mathExercises: (Exercise<{
 }, {
     displayType: string;
 }> | Exercise<{
+    labels: string[];
+    data: number[];
+    itemAsked: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    isAskingX: boolean;
+    xValue?: number;
+    yValue?: number;
+    a: number;
+    b: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    points: number[][];
+    labels: string[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
     indexSituation: number;
     bigNumber: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -4441,6 +4455,20 @@ declare const mathExercises: (Exercise<{
     evolutionType: string;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     quartiles: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    quartileIndex: 0 | 1 | 2 | 3 | 4;
+    quartiles: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    quartiles: number[];
+    arrQuartileIndex: (0 | 1 | 2 | 3 | 4)[];
+    typeQ: "below" | "between" | "above";
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    indexTopic: number;
+    isLess: boolean;
+    arrDistrib: {
+        name: string;
+        indicators: number[];
+    }[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     indexSituation: number;
     maxOrScam: 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/tree/nodes/algebraicNode.d.ts

@@ -16,6 +16,9 @@ export type SimplifyOptions = {
     forceSeparateSqrts?: boolean;
     forceAddFractions?: boolean;
     noAddOrder?: boolean;
+    forbidPowerMultiply?: boolean;
+    forbidPowerDivision?: boolean;
+    forbidPowerPower?: boolean;
 };
 export type EvaluateOptions = {
     degreeMode?: boolean;

package/lib/tree/nodes/algebraicNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kCAAkC,CAAC,EAAE,OAAO,CAAC;IAC7C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;CAGtB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe,KAAK,MAAM,CAAC;IAC5E,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,GAAG,CAAC,EAAE,OAAO,KAAK,aAAa,CAAC;IACnE,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;IAChD,mBAAmB,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,MAAM,CAAC;IACxD,mBAAmB,EAAE,MAAM,MAAM,CAAC;CACnC;AACD,8BAAsB,cAAc;;IAElC,OAAO,CAAC,MAAM,CAAC,QAAQ;CAGxB;AACD,eAAO,MAAM,eAAe,GAAI,MAAM,IAAI,KAAG,IAAI,IAAI,aACI,CAAC"}
+{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kCAAkC,CAAC,EAAE,OAAO,CAAC;IAC7C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAG5B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe,KAAK,MAAM,CAAC;IAC5E,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,GAAG,CAAC,EAAE,OAAO,KAAK,aAAa,CAAC;IACnE,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;IAChD,mBAAmB,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,MAAM,CAAC;IACxD,mBAAmB,EAAE,MAAM,MAAM,CAAC;CACnC;AACD,8BAAsB,cAAc;;IAElC,OAAO,CAAC,MAAM,CAAC,QAAQ;CAGxB;AACD,eAAO,MAAM,eAAe,GAAI,MAAM,IAAI,KAAG,IAAI,IAAI,aACI,CAAC"}

package/lib/tree/nodes/operators/fractionNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAK9E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAKrE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAMxD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,IAAI,GACf,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,OAAO,WAAW,iBAOnB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAC,QAAQ,CAAC;IACrB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;CAC7B,CAAC;AACF,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAiBpB,YAAY,IAAI,MAAM;IAItB,aAAa,IAAI,uBAAuB;IAQxC,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,mBAAmB;IAOnB,SAAS;IAoBT,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IA8BrC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,GAAG,UAAQ,GAAG,aAAa;IA8M5D,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,mBAAmB;IAQnB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,aAAa;CAQ5C"}
+{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAK9E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAKrE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAMxD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,IAAI,GACf,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,OAAO,WAAW,iBAOnB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAC,QAAQ,CAAC;IACrB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;CAC7B,CAAC;AACF,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAiBpB,YAAY,IAAI,MAAM;IAItB,aAAa,IAAI,uBAAuB;IAQxC,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,mBAAmB;IAOnB,SAAS;IAoBT,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IA8BrC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,GAAG,UAAQ,GAAG,aAAa;IA+M5D,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,mBAAmB;IAQnB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,aAAa;CAQ5C"}

package/lib/tree/nodes/operators/fractionNode.js

@@ -259,9 +259,11 @@ export class FractionNode {
             if (isFractionNode(denum) && isFractionNode(num)) {
                 return new MultiplyNode(num, new FractionNode(denum.rightChild, denum.leftChild)).simplify(opts);
             }
-            const powerSimp = powerSimplify(num, denum, opts);
-            if (powerSimp)
-                return powerSimp;
+            if (!opts?.forbidPowerDivision) {
+                const powerSimp = powerSimplify(num, denum, opts);
+                if (powerSimp)
+                    return powerSimp;
+            }
             if (num.equals(denum))
                 return new NumberNode(1);
             return null;

package/lib/tree/nodes/operators/multiplyNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,mBAAmB,CAAC;AAgB3B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAYrE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,GACnB,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,OAAO,WAAW,iBAOnB,CAAC;AACF,eAAO,MAAM,iBAAiB,GAAI,KAAK,aAAa,EAAE,SAYrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB;;OAEG;IACH,OAAO,qBAIL;IAEF,UAAU,qBAER;IACF,YAAY,IAAI,MAAM;IAItB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAgFrC,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAyFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,aAAa;;;;;;;;;IAYb,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAOtC,IAAI;IAGJ,cAAc;IACd,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,GAAG,UAAQ,GAAG,aAAa;IAiK5D,mBAAmB,CAAC,IAAI,CAAC,EAAE,eAAe;IAM1C,mBAAmB;IAOnB,MAAM,CAAC,IAAI,EAAE,aAAa;IAU1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAQxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}
+{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,mBAAmB,CAAC;AAgB3B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAYrE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,GACnB,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,OAAO,WAAW,iBAOnB,CAAC;AACF,eAAO,MAAM,iBAAiB,GAAI,KAAK,aAAa,EAAE,SAYrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB;;OAEG;IACH,OAAO,qBAIL;IAEF,UAAU,qBAER;IACF,YAAY,IAAI,MAAM;IAItB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAgFrC,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAyFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,aAAa;;;;;;;;;IAYb,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAOtC,IAAI;IAGJ,cAAc;IACd,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,GAAG,UAAQ,GAAG,aAAa;IAkK5D,mBAAmB,CAAC,IAAI,CAAC,EAAE,eAAe;IAM1C,mBAAmB;IAOnB,MAAM,CAAC,IAAI,EAAE,aAAa;IAU1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAQxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}

package/lib/tree/nodes/operators/multiplyNode.js

@@ -348,9 +348,11 @@ export class MultiplyNode {
             const fracSimplified = fractionSimplify(a, b, opts, log);
             if (fracSimplified)
                 return fracSimplified;
-            const powerSimplified = powerSimplify(a, b, opts, log);
-            if (powerSimplified)
-                return powerSimplified;
+            if (!opts?.forbidPowerMultiply) {
+                const powerSimplified = powerSimplify(a, b, opts, log);
+                if (powerSimplified)
+                    return powerSimplified;
+            }
             if (opts?.towardsDistribute && (isAddNode(a) || isSubstractNode(a))) {
                 return add(multiply(a.leftChild, b), multiply(a.rightChild, b)).simplify(opts, log);
             }

package/lib/tree/nodes/operators/powerNode.js

@@ -131,7 +131,7 @@ export class PowerNode {
             isNumberNode(rightSimplified)) {
             return new NumberNode(round(leftSimplified.value ** rightSimplified.value, 8));
         }
-        if (isPowerNode(leftSimplified)) {
+        if (!opts?.forbidPowerPower && isPowerNode(leftSimplified)) {
             return new PowerNode(leftSimplified.leftChild, new MultiplyNode(rightSimplified, leftSimplified.rightChild).simplify(opts)).simplify(opts);
         }
         if (isSqrtNode(leftSimplified) &&

package/package.json

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