math-exercises 3.0.134 → 3.0.136

package/lib/math/utils/functions/functionComposition.js

@@ -0,0 +1,117 @@
+import { isFunctionNode, } from "../../../tree/nodes/functions/functionNode.js";
+import { NodeConstructor } from "../../../tree/nodes/nodeConstructor.js";
+import { isOperatorNode, } from "../../../tree/nodes/operators/operatorNode.js";
+import { isVariableNode, } from "../../../tree/nodes/variables/variableNode.js";
+export const nodeBySubstitutingVar = (nodeCarrier, nodeInjected, variableNode = "x".toTree()) => {
+    function isTargetVariableNode(node) {
+        return isVariableNode(node) && node.name === variableNode.name;
+    }
+    const nodePathsWithVariableAtEnd = getAllNodePaths(nodeCarrier).filter((nodePathWithNodes) => isTargetVariableNode(nodePathWithNodes.arrNode[nodePathWithNodes.arrNode.length - 1]));
+    return nodePathsWithVariableAtEnd.reduce((acc, nodePathWithNodes) => nodeByReplacingNodeAtPath(acc, nodePathWithNodes.nodePath, nodeInjected), nodeCarrier);
+};
+export const getAllNodePaths = (node) => {
+    const arrNodePaths = [];
+    if (isOperatorNode(node)) {
+        getAllNodePaths(node.leftChild).forEach((nodePathWithNodes) => {
+            arrNodePaths.push({
+                arrNode: [node, ...nodePathWithNodes.arrNode],
+                nodePath: {
+                    keys: ["leftChild", ...nodePathWithNodes.nodePath.keys],
+                },
+            });
+        });
+        getAllNodePaths(node.rightChild).forEach((nodePathWithNodes) => {
+            arrNodePaths.push({
+                arrNode: [node, ...nodePathWithNodes.arrNode],
+                nodePath: {
+                    keys: ["rightChild", ...nodePathWithNodes.nodePath.keys],
+                },
+            });
+        });
+    }
+    else if (isFunctionNode(node)) {
+        getAllNodePaths(node.child).forEach((nodePathWithNodes) => {
+            arrNodePaths.push({
+                arrNode: [node, ...nodePathWithNodes.arrNode],
+                nodePath: {
+                    keys: ["child", ...nodePathWithNodes.nodePath.keys],
+                },
+            });
+        });
+    }
+    else {
+        arrNodePaths.push({
+            arrNode: [node],
+            nodePath: {
+                keys: [],
+            },
+        });
+    }
+    return arrNodePaths;
+};
+function functionNodeByReplacingChild(fNode, nodeChildNew) {
+    const nodeIds = fNode.toIdentifiers();
+    nodeIds.child = nodeChildNew.toIdentifiers();
+    return NodeConstructor.fromIdentifiers(nodeIds);
+}
+function operatorNodeByReplacingLeftChild(opNode, nodeLeftChildNew) {
+    const nodeIds = opNode.toIdentifiers();
+    nodeIds.leftChild = nodeLeftChildNew.toIdentifiers();
+    return NodeConstructor.fromIdentifiers(nodeIds);
+}
+function operatorNodeByReplacingRightChild(opNode, nodeRightChildNew) {
+    const nodeIds = opNode.toIdentifiers();
+    nodeIds.rightChild = nodeRightChildNew.toIdentifiers();
+    return NodeConstructor.fromIdentifiers(nodeIds);
+}
+export function nodeByReplacingNodeAtPath(nodeCarrier, path, nodeInjected, simplifyUpToLevel = -1, simplifyOptions = {}) {
+    // console.log("nodeByReplacingNodeAtPath", {
+    //   node: nodeCarrier.toTex(),
+    //   key: path.keys.join("."),
+    //   nodeInjected: nodeInjected.toTex(),
+    // });
+    function getNodeForKey(node, key) {
+        if (key === "leftChild" || key === "rightChild") {
+            return node[key];
+        }
+        else if (key === "child") {
+            return node[key];
+        }
+        else {
+            throw new Error("Unsupported key in path.keys: " + key);
+        }
+    }
+    function nodeByReplacingChildAtKey(node, key, nodeInjected) {
+        // console.log("nodeByReplacingChildAtKey", {
+        //   node: node.toTex(),
+        //   key: key,
+        //   nodeInjected: nodeInjected.toTex(),
+        // });
+        if (key === "leftChild" && isOperatorNode(node)) {
+            return operatorNodeByReplacingLeftChild(node, nodeInjected);
+        }
+        else if (key === "rightChild" && isOperatorNode(node)) {
+            return operatorNodeByReplacingRightChild(node, nodeInjected);
+        }
+        else if (key === "child" && isFunctionNode(node)) {
+            return functionNodeByReplacingChild(node, nodeInjected);
+        }
+        else {
+            throw new Error("Either key and node type are incompatible or Unsupported key: " + key);
+        }
+    }
+    const arrNodeReversed = path.keys
+        .slice(0, -1)
+        .reduce((acc, key) => {
+        return [...acc, getNodeForKey(acc[acc.length - 1], key)];
+    }, [nodeCarrier])
+        .toReversed();
+    return path.keys.toReversed().reduce((acc, key, i) => {
+        const carrierNode = arrNodeReversed[i];
+        let nodeReplacement = nodeByReplacingChildAtKey(carrierNode, key, acc);
+        if (i <= simplifyUpToLevel) {
+            nodeReplacement = nodeReplacement.simplify(simplifyOptions);
+        }
+        return nodeReplacement;
+    }, nodeInjected);
+}

package/lib/math/utils/functions/functionDecomposition.d.ts

@@ -0,0 +1,10 @@
+import { AlgebraicNode } from "../../../tree/nodes/algebraicNode.js";
+import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
+export declare const functionDecompositions: (node: AlgebraicNode, variableNode?: VariableNode) => {
+    nodeU: AlgebraicNode;
+    nodeV: AlgebraicNode;
+}[];
+export declare const nodeBySubstitutingX: (node: AlgebraicNode, strVar: string) => AlgebraicNode;
+export declare function composeNodes(nodeU: AlgebraicNode, nodeV: AlgebraicNode): AlgebraicNode;
+export declare function isContainingFacetiousFrac(node: AlgebraicNode): boolean;
+//# sourceMappingURL=functionDecomposition.d.ts.map

package/lib/math/utils/functions/functionDecomposition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionDecomposition.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionDecomposition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAYlE,OAAO,EAEL,YAAY,EACb,MAAM,4CAA4C,CAAC;AAcpD,eAAO,MAAM,sBAAsB,GACjC,MAAM,aAAa,EACnB,eAAc,YAA2C;WAElC,aAAa;WAAS,aAAa;GA8Q3D,CAAC;AAwEF,eAAO,MAAM,mBAAmB,GAAI,MAAM,aAAa,EAAE,QAAQ,MAAM,kBAItE,CAAC;AAEF,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,iBAMtE;AAMD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAmBtE"}

package/lib/math/utils/functions/functionDecomposition.js

@@ -0,0 +1,256 @@
+import { abs } from "../../../tree/nodes/functions/absNode.js";
+import { isFunctionNode } from "../../../tree/nodes/functions/functionNode.js";
+import { isNumberNode } from "../../../tree/nodes/numbers/numberNode.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { frac, isFractionNode, } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { isOperatorNode } from "../../../tree/nodes/operators/operatorNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { isVariableNode, } from "../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { randomMany } from "../../../utils/alea/random.js";
+import { getCartesiansProducts } from "../../../utils/arrays/cartesianProducts.js";
+import { getAllNodePaths, nodeByReplacingNodeAtPath, } from "./functionComposition.js";
+//
+// Function decompositions: get all (u,v) so that f = uov
+//
+export const functionDecompositions = (node, variableNode = "x".toTree()) => {
+    const outArr = [];
+    function isTargetVariableNode(node) {
+        return isVariableNode(node) && node.name === variableNode.name;
+    }
+    const nodePathsWithVariableAtEnd = getAllNodePaths(node).filter((nodePathWithNodes) => isTargetVariableNode(nodePathWithNodes.arrNode[nodePathWithNodes.arrNode.length - 1]));
+    function nodePathUpward(nodePathWithNodes, level) {
+        return {
+            arrNode: nodePathWithNodes.arrNode.slice(0, nodePathWithNodes.arrNode.length - level),
+            nodePath: {
+                keys: nodePathWithNodes.nodePath.keys.slice(0, nodePathWithNodes.nodePath.keys.length - level),
+            },
+        };
+    }
+    function isNodesAreSame(node1, node2) {
+        const value = substract(node1, node2)
+            .simplify()
+            .evaluate({ [variableNode.name]: 177 });
+        return value === 0;
+    }
+    function isValidNodeU(nodeU) {
+        return (!isContainingFacetiousFrac(nodeU) &&
+            !nodeU.toTex().includes("NaN") &&
+            outArr.every(({ nodeU: nodeUExisting }) => !isNodesAreSame(nodeU, nodeUExisting)));
+    }
+    let counter = 0;
+    const levelPicks = getCartesiansProducts(nodePathsWithVariableAtEnd.map((nodePathWithNodes) => [
+        ...Array(nodePathWithNodes.nodePath.keys.length).keys(),
+    ]));
+    // console.log("levelPicks", levelPicks.length);
+    levelPicks.forEach((levelPick) => {
+        if (counter > 1000) {
+            return outArr;
+        }
+        else {
+            const nodePathsUpByLevel = nodePathsWithVariableAtEnd.map((nodePathWithNodes, i) => {
+                const level = levelPick[i];
+                return nodePathUpward(nodePathWithNodes, level);
+            });
+            // console.log(
+            //   "nodePathsUpByLevel",
+            //   nodePathsUpByLevel.map((nodePathWithNodes) => {
+            //     return {
+            //       endNode:
+            //         nodePathWithNodes.arrNode[
+            //           nodePathWithNodes.arrNode.length - 1
+            //         ].toTex(),
+            //       keypath: nodePathWithNodes.nodePath.keys.join("."),
+            //     };
+            //   }),
+            // );
+            //merge wrt collision (collision means that some of the wrappedVariables trees are superimposing, and we don't want that)
+            const mergedNodePathsUpByLevel = nodePathsUpByLevel.reduce((acc, incomingNodePathWithNodes) => {
+                const incomingNodePathsString = incomingNodePathWithNodes.nodePath.keys.join(".");
+                const isIncomingIncluded = acc.some((accumulatedNodePathWithNodes) => {
+                    const accumulatedNodePathsString = accumulatedNodePathWithNodes.nodePath.keys.join(".");
+                    return incomingNodePathsString.startsWith(accumulatedNodePathsString);
+                });
+                const nodesPathsNotIncludedByIncoming = acc.filter((accumulatedNodePathWithNodes) => {
+                    const accumulatedNodePathsString = accumulatedNodePathWithNodes.nodePath.keys.join(".");
+                    return !accumulatedNodePathsString.startsWith(incomingNodePathsString);
+                });
+                if (isIncomingIncluded) {
+                    return acc;
+                }
+                else if (nodesPathsNotIncludedByIncoming.length !== acc.length) {
+                    return [
+                        ...nodesPathsNotIncludedByIncoming,
+                        incomingNodePathWithNodes,
+                    ];
+                }
+                else {
+                    return [...acc, incomingNodePathWithNodes];
+                }
+            }, []);
+            // console.log(
+            //   "mergedNodePathsUpByLevel",
+            //   mergedNodePathsUpByLevel.map((nodePathWithNodes) => {
+            //     return {
+            //       endNode:
+            //         nodePathWithNodes.arrNode[
+            //           nodePathWithNodes.arrNode.length - 1
+            //         ].toTex(),
+            //       keypath: nodePathWithNodes.nodePath.keys.join("."),
+            //     };
+            //   }),
+            // );
+            const wrappedVariables = mergedNodePathsUpByLevel.map((nodePathWithNodes) => nodePathWithNodes &&
+                nodePathWithNodes.arrNode[nodePathWithNodes.arrNode.length - 1]);
+            for (let index = 0; index < wrappedVariables.length; index++) {
+                const sameNodeCandidate = wrappedVariables[index];
+                const otherWrappedVariables = wrappedVariables.filter((_, i) => i !== index);
+                const isSameNode = otherWrappedVariables.every((node) => isNodesAreSame(node, sameNodeCandidate));
+                if (isSameNode) {
+                    const sameNode = sameNodeCandidate;
+                    //replaces all sameNode with variableNode
+                    const nodeU = mergedNodePathsUpByLevel.reduce((acc, nodePathWithNodes) => nodeByReplacingNodeAtPath(acc, nodePathWithNodes.nodePath, variableNode), node);
+                    if (isValidNodeU(nodeU)) {
+                        const nodeV = sameNode;
+                        outArr.push({ nodeU, nodeV });
+                    }
+                }
+                else {
+                    //attempt salvation
+                    const comparisonDicts = otherWrappedVariables.map((node) => getComparisonDict(node, sameNodeCandidate));
+                    // console.log(
+                    //   "comparisonDicts",
+                    //   comparisonDicts.map((comparisonDict) => {
+                    //     return {
+                    //       sub: comparisonDict?.sub?.toTex(),
+                    //       frac: comparisonDict?.frac?.toTex(),
+                    //     };
+                    //   }),
+                    // );
+                    const isSalvationPossible = comparisonDicts.every((comparisonDict) => comparisonDict?.sub !== undefined ||
+                        comparisonDict?.frac !== undefined);
+                    if (isSalvationPossible) {
+                        const nodeGaskets = comparisonDicts.map((comparisonDict) => {
+                            if (comparisonDict.sub !== undefined) {
+                                return add(variableNode, comparisonDict.sub);
+                            }
+                            else {
+                                return multiply(comparisonDict.frac, variableNode);
+                            }
+                        });
+                        // console.log(
+                        //   "nodeGaskets",
+                        //   nodeGaskets.map((node) => node.toTex()),
+                        // );
+                        const nodeUEnds = [...Array(wrappedVariables.length).keys()].map((i) => {
+                            if (i === index) {
+                                return variableNode;
+                            }
+                            else {
+                                return nodeGaskets[i < index ? i : i - 1];
+                            }
+                        });
+                        let nodeU;
+                        try {
+                            nodeU = mergedNodePathsUpByLevel.reduce((acc, nodePathWithNodes, i) => nodeByReplacingNodeAtPath(acc, nodePathWithNodes.nodePath, nodeUEnds[i], 1, {}), node);
+                        }
+                        catch (_) {
+                            try {
+                                nodeU = mergedNodePathsUpByLevel.reduce((acc, nodePathWithNodes, i) => nodeByReplacingNodeAtPath(acc, nodePathWithNodes.nodePath, nodeUEnds[i], 0, {}), node);
+                            }
+                            catch (_) {
+                                nodeU = mergedNodePathsUpByLevel.reduce((acc, nodePathWithNodes, i) => nodeByReplacingNodeAtPath(acc, nodePathWithNodes.nodePath, nodeUEnds[i]), node);
+                            }
+                        }
+                        if (isValidNodeU(nodeU)) {
+                            const nodeV = sameNodeCandidate;
+                            outArr.push({ nodeU, nodeV });
+                        }
+                    }
+                }
+            }
+        }
+        counter++;
+    });
+    return outArr;
+};
+//
+// Function comparison
+//
+function getComparisonDict(node1, node2) {
+    const pool = [...Array(1000).keys()].map((i) => i - 500);
+    const evals = randomMany(pool, 5).map((x) => {
+        let v1;
+        try {
+            v1 = node1.evaluate({ x });
+        }
+        catch (_) {
+            v1 = undefined;
+        }
+        let v2;
+        try {
+            v2 = node2.evaluate({ x });
+        }
+        catch (_) {
+            v2 = undefined;
+        }
+        return { v1, v2 };
+    });
+    const successfulEvals = evals.filter(({ v1, v2 }) => v1 !== undefined && v2 !== undefined);
+    if (successfulEvals.length > 4) {
+        return {
+            sub: successfulEvals
+                .slice(1)
+                .every(({ v1, v2 }) => v1 - v2 === successfulEvals[0].v1 - successfulEvals[0].v2)
+                ? substract(successfulEvals[0].v1, successfulEvals[0].v2).simplify()
+                : undefined,
+            frac: (() => {
+                const successfulEvalsWithoutZeroV2 = successfulEvals.filter(({ v2 }) => v2 !== 0);
+                // console.log(
+                //   "successfulEvalsWithoutZeroV2",
+                //   successfulEvalsWithoutZeroV2,
+                // );
+                return successfulEvalsWithoutZeroV2
+                    .slice(1)
+                    .every(({ v1, v2 }) => substract(frac(v1, v2), frac(successfulEvalsWithoutZeroV2[0].v1, successfulEvalsWithoutZeroV2[0].v2)).evaluate() === 0)
+                    ? frac(successfulEvalsWithoutZeroV2[0].v1, successfulEvalsWithoutZeroV2[0].v2).simplify({ towardsDistribute: true })
+                    : undefined;
+            })(),
+        };
+    }
+    else {
+        return undefined;
+    }
+}
+//
+// Function composition
+//
+export const nodeBySubstitutingX = (node, strVar) => {
+    return parseAlgebraic(node.toTex({ forceParenthesis: true }).replaceAll("x", `("${strVar}")`));
+};
+export function composeNodes(nodeU, nodeV) {
+    const nodeUOV = nodeBySubstitutingX(nodeU.simplify(), nodeV.simplify().toTex()).simplify();
+    return nodeUOV;
+}
+//
+// facetious fracs
+//
+export function isContainingFacetiousFrac(node) {
+    if (isOperatorNode(node)) {
+        if (isFractionNode(node)) {
+            return [node.leftChild, node.rightChild].every((nodeChild) => isNumberNode(nodeChild) &&
+                abs(nodeChild).evaluate() > Math.pow(10, 10));
+        }
+        else {
+            return (isContainingFacetiousFrac(node.leftChild) ||
+                isContainingFacetiousFrac(node.rightChild));
+        }
+    }
+    else if (isFunctionNode(node)) {
+        return isContainingFacetiousFrac(node.child);
+    }
+    else {
+        return false;
+    }
+}

package/lib/server.js

@@ -30,6 +30,7 @@ const runServer = () => {
     console.log("math exos", mathExercises.length);
     console.log("math hints", mathExercises.filter((exo) => exo.hasHintAndCorrection).length);
     console.log("pc exos", `${pcExercises.length}`);
+    console.log("pc hints", pcExercises.filter((exo) => exo.hasHintAndCorrection).length);
     playground();
     logIdentifiers();
     app.get("/", (_req, res) => {
@@ -45,7 +46,7 @@ const runServer = () => {
         const n = Number(req.query.n);
         const exoId = req.query.exoId;
         const options = req.query.options
-            ? JSON.parse(req.query.options)
+            ? JSON.parse(decodeURIComponent(req.query.options))
             : undefined;
         const exo = allExercises.find((exo) => exo.id == exoId);
         if (!exo) {
@@ -63,10 +64,10 @@ const runServer = () => {
             return;
         }
         const identifiers = req.query.identifiers
-            ? JSON.parse(req.query.identifiers)
+            ? JSON.parse(decodeURIComponent(req.query.identifiers))
             : undefined;
         const options = req.query.options
-            ? JSON.parse(req.query.options)
+            ? JSON.parse(decodeURIComponent(req.query.options))
             : undefined;
         const question = exo?.getQuestionFromIdentifiers(identifiers, options);
         res.json({
@@ -78,16 +79,13 @@ const runServer = () => {
         const n = Number(req.query.n) || 4;
         const exoId = req.query.exoId;
         const options = req.query.options
-            ? JSON.parse(req.query.options)
+            ? JSON.parse(decodeURIComponent(req.query.options))
             : undefined;
         const identifiers = req.query.identifiers
-            ? JSON.parse(req.query.identifiers)
+            ? JSON.parse(decodeURIComponent(req.query.identifiers))
             : undefined;
-        console.log("raw", req.query.answer);
-        console.log("dec", decodeURI(req.query.answer));
-        const answer = JSON.parse(decodeURI(req.query.answer));
+        const answer = JSON.parse(decodeURIComponent(req.query.answer));
         const exo = allExercises.find((exo) => exo.id == exoId);
-        console.log("ans", answer);
         if (!exo) {
             res.send("Exo not found");
             return;
@@ -96,19 +94,19 @@ const runServer = () => {
             res.send("no getPropositions");
             return;
         }
-        const props = exo.getPropositions(n, { answer: exo.getAnswer?.(identifiers, options) ?? "", ...identifiers }, options);
+        const props = exo.getPropositions(n, { answer, ...identifiers }, options);
         res.json(props);
     });
     app.get("/isAnswerTableValid", (req, res) => {
         const exoId = req.query.exoId;
         const options = req.query.options
-            ? JSON.parse(req.query.options)
+            ? JSON.parse(decodeURIComponent(req.query.options))
             : undefined;
         const identifiers = req.query.identifiers
-            ? JSON.parse(req.query.identifiers)
+            ? JSON.parse(decodeURIComponent(req.query.identifiers))
             : undefined;
-        const studentAnswer = JSON.parse(req.query.studentAnswer);
-        const answerTable = JSON.parse(req.query.answerTable);
+        const studentAnswer = JSON.parse(decodeURIComponent(req.query.studentAnswer));
+        const answerTable = JSON.parse(decodeURIComponent(req.query.answerTable));
         const exo = allExercises.find((exo) => exo.id == exoId);
         if (!exo) {
             res.send("Exo not found");
@@ -124,13 +122,13 @@ const runServer = () => {
     app.get("/isAnswerValid", (req, res) => {
         const exoId = req.query.exoId;
         const options = req.query.options
-            ? JSON.parse(req.query.options)
+            ? JSON.parse(decodeURIComponent(req.query.options))
             : undefined;
         const identifiers = req.query.identifiers
-            ? JSON.parse(req.query.identifiers)
+            ? JSON.parse(decodeURIComponent(req.query.identifiers))
             : undefined;
-        const studentAnswer = JSON.parse(req.query.studentAnswer);
-        const answer = JSON.parse(req.query.answer);
+        const studentAnswer = JSON.parse(decodeURIComponent(req.query.studentAnswer));
+        const answer = JSON.parse(decodeURIComponent(req.query.answer));
         const exo = allExercises.find((exo) => exo.id == exoId);
         if (!exo) {
             res.send("Exo not found");
@@ -140,21 +138,19 @@ const runServer = () => {
             res.send("no isAnswerValid");
             return;
         }
-        console.log("there");
         const valid = exo.isAnswerValid(studentAnswer, { answer, ...identifiers }, options);
-        console.log(valid);
         res.json(valid);
     });
     app.get("/isGGBAnswerValid", (req, res) => {
         const exoId = req.query.exoId;
         const options = req.query.options
-            ? JSON.parse(req.query.options)
+            ? JSON.parse(decodeURIComponent(req.query.options))
             : undefined;
         const identifiers = req.query.identifiers
-            ? JSON.parse(req.query.identifiers)
+            ? JSON.parse(decodeURIComponent(req.query.identifiers))
             : undefined;
-        const studentAnswer = JSON.parse(req.query.studentAnswer);
-        const ggbAnswer = JSON.parse(req.query.ggbAnswer);
+        const studentAnswer = JSON.parse(decodeURIComponent(req.query.studentAnswer));
+        const ggbAnswer = JSON.parse(decodeURIComponent(req.query.ggbAnswer));
         const exo = allExercises.find((exo) => exo.id == exoId);
         if (!exo) {
             res.send("Exo not found");
@@ -170,7 +166,7 @@ const runServer = () => {
     app.get("/question", (req, res) => {
         const exoId = req.query.exoId;
         const options = req.query.options
-            ? JSON.parse(req.query.options)
+            ? JSON.parse(decodeURIComponent(req.query.options))
             : undefined;
         const exoIndex = allExercises.findIndex((exo) => exo.id == exoId);
         const exo = allExercises[exoIndex];
@@ -185,7 +181,7 @@ const runServer = () => {
     app.get("/exo", (req, res) => {
         const exoId = req.query.exoId;
         const options = req.query.options
-            ? JSON.parse(req.query.options)
+            ? JSON.parse(decodeURIComponent(req.query.options))
             : undefined;
         const exoIndex = allExercises.findIndex((exo) => exo.id == exoId);
         const exo = allExercises[exoIndex];
@@ -203,7 +199,7 @@ const runServer = () => {
     app.get("/qcmExo", (req, res) => {
         const exoId = req.query.exoId;
         const options = req.query.options
-            ? JSON.parse(req.query.options)
+            ? JSON.parse(decodeURIComponent(req.query.options))
             : undefined;
         const exoIndex = allExercises.findIndex((exo) => exo.id == exoId);
         const exo = allExercises[exoIndex];
@@ -230,7 +226,7 @@ const runServer = () => {
     app.post("/vea", jsonParser, (req, res) => {
         const exoId = req.query.exoId;
         const options = req.query.options
-            ? JSON.parse(req.query.options)
+            ? JSON.parse(decodeURIComponent(req.query.options))
             : undefined;
         const { ans, veaProps } = req.body;
         const exoIndex = allExercises.findIndex((exo) => exo.id == exoId);
@@ -251,7 +247,7 @@ const runServer = () => {
     app.post("/tableVea", jsonParser, (req, res) => {
         const exoId = req.query.exoId;
         const options = req.query.options
-            ? JSON.parse(req.query.options)
+            ? JSON.parse(decodeURIComponent(req.query.options))
             : undefined;
         const { ans, veaProps } = req.body;
         const exoIndex = allExercises.findIndex((exo) => exo.id == exoId);

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

@@ -1 +1 @@
-{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.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;AAG9E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAKrE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AACD,eAAO,MAAM,MAAM,GAAI,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,eAKxD,CAAC;AAEF,eAAO,MAAM,KAAK,GAChB,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,OAAO,WAAW,cAOnB,CAAC;AAEF,qBAAa,SAAU,YAAW,YAAY;IAC5C,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,YAAY,IAAI,MAAM;IAGtB,aAAa;;;;;;;;;IAOb,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM;IAuBlC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,IAAI,UAAQ,GAAG,aAAa;IA6D7D,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAcxD;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;CAIrD"}
+{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.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;AAG9E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAMrE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AACD,eAAO,MAAM,MAAM,GAAI,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,eAKxD,CAAC;AAEF,eAAO,MAAM,KAAK,GAChB,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,OAAO,WAAW,cAOnB,CAAC;AAEF,qBAAa,SAAU,YAAW,YAAY;IAC5C,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,YAAY,IAAI,MAAM;IAGtB,aAAa;;;;;;;;;IAOb,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM;IA0BlC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,IAAI,UAAQ,GAAG,aAAa;IA6D7D,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAcxD;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;CAIrD"}

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

@@ -6,6 +6,7 @@ import { MultiplyNode, isMultiplyNode, multiply } from "./multiplyNode.js";
 import { isSqrtNode } from "../functions/sqrtNode.js";
 import { round } from "../../../math/utils/round.js";
 import { FractionNode, isFractionNode } from "./fractionNode.js";
+import { FunctionsIds, isFunctionNode } from "../functions/functionNode.js";
 export function isPowerNode(a) {
     return isOperatorNode(a) && a.id === OperatorIds.power;
 }
@@ -84,6 +85,9 @@ export class PowerNode {
                 OperatorIds.power,
             ].includes(this.leftChild.id);
         }
+        if (isFunctionNode(this.leftChild)) {
+            needBrackets ||= [FunctionsIds.exp].includes(this.leftChild.id);
+        }
         if (needBrackets)
             leftTex = `\\left(${leftTex}\\right)`;
         const needBrace = rightTex.length > 1;

package/lib/utils/strings/joinanded.d.ts

@@ -0,0 +1,2 @@
+export declare const joinanded: (arrStr: string[], separator: string, lastSeparator: string) => string;
+//# sourceMappingURL=joinanded.d.ts.map

package/lib/utils/strings/joinanded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"joinanded.d.ts","sourceRoot":"","sources":["../../../src/utils/strings/joinanded.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,GACpB,QAAQ,MAAM,EAAE,EAChB,WAAW,MAAM,EACjB,eAAe,MAAM,WAWtB,CAAC"}

package/lib/utils/strings/joinanded.js

@@ -0,0 +1,11 @@
+export const joinanded = (arrStr, separator, lastSeparator) => {
+    if (arrStr.length === 0) {
+        return "";
+    }
+    else if (arrStr.length === 1) {
+        return arrStr[0];
+    }
+    else {
+        return `${arrStr.slice(0, -1).join(separator)}${lastSeparator}${arrStr[arrStr.length - 1]}`;
+    }
+};

package/package.json

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