math-exercises 3.0.133 → 3.0.135

package/lib/math/utils/arithmetic/primeDecompNode.js

@@ -0,0 +1,24 @@
+import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../tree/nodes/operators/powerNode.js";
+import { operatorComposition } from "../../../tree/utilities/operatorComposition.js";
+import { primeDecomposition } from "./primeDecomposition.js";
+export const primeDecompNode = (nb, asPowers = true) => {
+    const decomp = primeDecomposition(nb);
+    const nodes = [];
+    if (asPowers) {
+        for (const d of decomp) {
+            if (d.power === 1)
+                nodes.push(d.value.toTree());
+            else
+                nodes.push(power(d.value, d.power));
+        }
+    }
+    else {
+        for (const d of decomp) {
+            for (let i = 0; i < d.power; i++) {
+                nodes.push(d.value.toTree());
+            }
+        }
+    }
+    return operatorComposition(MultiplyNode, nodes);
+};

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

@@ -0,0 +1,3 @@
+import { AlgebraicNode } from "../../../tree/nodes/algebraicNode.js";
+export declare const isEquivalentNodes: (node1: AlgebraicNode, node2: AlgebraicNode) => boolean;
+//# sourceMappingURL=functionComparison.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"functionComparison.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionComparison.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAsElE,eAAO,MAAM,iBAAiB,GAC5B,OAAO,aAAa,EACpB,OAAO,aAAa,YAarB,CAAC"}

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

@@ -0,0 +1,58 @@
+import { isInfiniteNode } from "../../../tree/nodes/numbers/constantNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { randfloat } from "../random/randfloat.js";
+const getSafeEvaluationDictForEqualityCheck = (node1, node2, nbSafeX = 4) => {
+    const dict = {};
+    let counter = -1;
+    while (Object.keys(dict).length < nbSafeX && counter < 1000) {
+        counter++;
+        const x = randfloat(-20, 100, 3);
+        let value1;
+        let value2;
+        try {
+            value1 = node1.evaluate({ x });
+        }
+        catch (_) {
+            continue;
+        }
+        try {
+            value2 = node2.evaluate({ x });
+        }
+        catch (_) {
+            continue;
+        }
+        const [isValidValue1, isValidValue2] = [value1, value2].map((value) => value !== undefined && !isNaN(value) && !isInfiniteNode(value.toTree()));
+        if (isValidValue1 && isValidValue2) {
+            dict[x] = [value1, value2].map((value) => {
+                return {
+                    x,
+                    value,
+                };
+            });
+        }
+    }
+    return dict;
+};
+const isEqualFromRandomEvaluations = (node1, node2) => {
+    return Object.values(getSafeEvaluationDictForEqualityCheck(node1, node2)).every((arrSafeEval) => {
+        // console.log(
+        //   "arrSafeEval",
+        //   arrSafeEval.map((safeEval) => safeEval.value),
+        // );
+        return arrSafeEval
+            .slice(1)
+            .every((safeEval) => substract(arrSafeEval[0].value, safeEval.value).evaluate() === 0);
+    });
+};
+export const isEquivalentNodes = (node1, node2) => {
+    let isEqualFromAlgebraicSimplification = false;
+    try {
+        isEqualFromAlgebraicSimplification =
+            substract(node1, node2).simplify().evaluate() === 0;
+    }
+    catch (_) {
+        (() => { })();
+    }
+    return (isEqualFromAlgebraicSimplification ||
+        isEqualFromRandomEvaluations(node1, node2));
+};

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

@@ -0,0 +1,13 @@
+import { AlgebraicNode, SimplifyOptions } from "../../../tree/nodes/algebraicNode.js";
+import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
+export declare const nodeBySubstitutingVar: (nodeCarrier: AlgebraicNode, nodeInjected: AlgebraicNode, variableNode?: VariableNode) => AlgebraicNode;
+export type NodePathWithNodes = {
+    arrNode: AlgebraicNode[];
+    nodePath: NodePath;
+};
+export declare const getAllNodePaths: (node: AlgebraicNode) => NodePathWithNodes[];
+export type NodePath = {
+    keys: ("leftChild" | "rightChild" | "child")[];
+};
+export declare function nodeByReplacingNodeAtPath(nodeCarrier: AlgebraicNode, path: NodePath, nodeInjected: AlgebraicNode, simplifyUpToLevel?: number, simplifyOptions?: SimplifyOptions): AlgebraicNode;
+//# sourceMappingURL=functionComposition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAU3C,OAAO,EAEL,YAAY,EACb,MAAM,4CAA4C,CAAC;AAEpD,eAAO,MAAM,qBAAqB,GAChC,aAAa,aAAa,EAC1B,cAAc,aAAa,EAC3B,eAAc,YAA2C,kBAiB1D,CAAC;AAMF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,MAAM,aAAa,wBA4ClD,CAAC;AAMF,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,CAAC,WAAW,GAAG,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC;CAChD,CAAC;AA6BF,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,aAAa,EAC1B,IAAI,EAAE,QAAQ,EACd,YAAY,EAAE,aAAa,EAC3B,iBAAiB,GAAE,MAAW,EAC9B,eAAe,GAAE,eAAoB,iBAiEtC"}

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,12 +79,12 @@ 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;
-        const answer = req.query.answer;
+        const answer = JSON.parse(decodeURIComponent(req.query.answer));
         const exo = allExercises.find((exo) => exo.id == exoId);
         if (!exo) {
             res.send("Exo not found");
@@ -99,13 +100,13 @@ const runServer = () => {
     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");
@@ -121,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");
@@ -143,13 +144,13 @@ const runServer = () => {
     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");
@@ -165,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];
@@ -180,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];
@@ -198,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];
@@ -225,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);
@@ -246,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"}