math-exercises 1.2.10 → 1.3.0

package/lib/tree/parsers/latexParser.js

@@ -1,117 +1,110 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.latexParser = void 0;
-const functionNode_1 = require("../nodes/functions/functionNode");
-const node_1 = require("../nodes/node");
-const operatorNode_1 = require("../nodes/operators/operatorNode");
-function latexParser(node) {
-    if (!node) {
-        console.log("parsing a null node ???");
-        return "";
-    }
-    switch (node.type) {
-        case node_1.NodeType.variable:
-            return node.tex;
-        case node_1.NodeType.number:
-            return node.tex;
-        case node_1.NodeType.operator:
-            const operatorNode = node;
-            let rightTex = latexParser(operatorNode.rightChild);
-            let leftTex = latexParser(operatorNode.leftChild);
-            const { leftChild, rightChild } = operatorNode;
-            switch (operatorNode.id) {
-                case operatorNode_1.OperatorIds.add:
-                    return `${leftTex} ${rightTex[0] === "-" ? "" : "+ "}${rightTex}`;
-                case operatorNode_1.OperatorIds.substract: {
-                    const needBrackets = (rightChild.type === node_1.NodeType.operator &&
-                        [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(rightChild.id)) ||
-                        rightTex[0] === "-";
-                    if (needBrackets)
-                        rightTex = `(${rightTex})`;
-                    return `${leftTex} - ${rightTex}`;
-                }
-                case operatorNode_1.OperatorIds.multiply: {
-                    if (leftChild.type === node_1.NodeType.operator) {
-                        if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(leftChild.id))
-                            leftTex = `(${leftTex})`;
-                    }
-                    let needBrackets = rightTex[0] === "-";
-                    if (rightChild.type === node_1.NodeType.operator) {
-                        const operatorRightChild = rightChild;
-                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
-                    }
-                    if (needBrackets)
-                        rightTex = `(${rightTex})`;
-                    //  permet de gérer le cas 3*2^x
-                    let showTimesSign = !isNaN(+rightTex[0]) || rightChild.type === node_1.NodeType.number;
-                    if (rightChild.type === node_1.NodeType.operator) {
-                        const operatorRightChild = rightChild;
-                        showTimesSign || (showTimesSign = [operatorNode_1.OperatorIds.fraction].includes(operatorRightChild.id));
-                    }
-                    return `${leftTex}${showTimesSign ? "\\times " : ""}${rightTex}`;
-                }
-                case operatorNode_1.OperatorIds.divide: {
-                    if (leftChild.type === node_1.NodeType.operator) {
-                        if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.multiply].includes(leftChild.id))
-                            leftTex = `(${leftTex})`;
-                    }
-                    let needBrackets = rightTex[0] === "-";
-                    if (rightChild.type === node_1.NodeType.operator) {
-                        const operatorRightChild = rightChild;
-                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
-                    }
-                    if (needBrackets)
-                        rightTex = `(${rightTex})`;
-                    return `${leftTex} \\div ${rightTex}`;
-                }
-                case operatorNode_1.OperatorIds.fraction: {
-                    return `\\frac{${leftTex}}{${rightTex}}`;
-                }
-                case operatorNode_1.OperatorIds.power: {
-                    let needBrackets = leftTex[0] === "-";
-                    if (leftChild.type === node_1.NodeType.operator) {
-                        const childOperator = leftChild;
-                        needBrackets || (needBrackets = [
-                            operatorNode_1.OperatorIds.add,
-                            operatorNode_1.OperatorIds.substract,
-                            operatorNode_1.OperatorIds.multiply,
-                            operatorNode_1.OperatorIds.divide,
-                            operatorNode_1.OperatorIds.fraction,
-                            operatorNode_1.OperatorIds.power,
-                        ].includes(childOperator.id));
-                    }
-                    if (needBrackets)
-                        leftTex = `(${leftTex})`;
-                    return `${leftTex}^{${rightTex}}`;
-                }
-                case operatorNode_1.OperatorIds.equal: {
-                    return `${leftTex} = ${rightTex}`;
-                }
-                default:
-                    return node.tex;
-            }
-        case node_1.NodeType.function: {
-            const functionNode = node;
-            const child = functionNode.child;
-            let childTex = latexParser(functionNode.child);
-            switch (functionNode.id) {
-                case functionNode_1.FunctionsIds.sqrt: {
-                    return `\\sqrt{${childTex}}`;
-                }
-                case functionNode_1.FunctionsIds.opposite: {
-                    let needBrackets = childTex[0] === "-";
-                    if (child.type === node_1.NodeType.operator) {
-                        const operatorChild = child;
-                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorChild.id));
-                    }
-                    if (needBrackets)
-                        childTex = `(${childTex})`;
-                    return `-${childTex}`;
-                }
-            }
-        }
-        default:
-            return "";
-    }
-}
-exports.latexParser = latexParser;
+// import { FunctionNode, FunctionsIds } from "../nodes/functions/functionNode";
+// import { Node, NodeType } from "../nodes/node";
+// import { OperatorIds, OperatorNode } from "../nodes/operators/operatorNode";
+// export function latexParser(node: Node): string {
+//   if (!node) {
+//     console.log("parsing a null node ???");
+//     return "";
+//   }
+//   switch (node.type) {
+//     case NodeType.variable:
+//       return node.tex;
+//     case NodeType.number:
+//       return node.tex;
+//     case NodeType.operator:
+//       const operatorNode = node as OperatorNode;
+//       let rightTex = latexParser(operatorNode.rightChild);
+//       let leftTex = latexParser(operatorNode.leftChild);
+//       const { leftChild, rightChild } = operatorNode;
+//       switch (operatorNode.id) {
+//         case OperatorIds.add:
+//           return `${leftTex} ${rightTex[0] === "-" ? "" : "+ "}${rightTex}`;
+//         case OperatorIds.substract: {
+//           const needBrackets =
+//             (rightChild.type === NodeType.operator &&
+//               [OperatorIds.add, OperatorIds.substract].includes((rightChild as OperatorNode).id)) ||
+//             rightTex[0] === "-";
+//           if (needBrackets) rightTex = `(${rightTex})`;
+//           return `${leftTex} - ${rightTex}`;
+//         }
+//         case OperatorIds.multiply: {
+//           if (leftChild.type === NodeType.operator) {
+//             if ([OperatorIds.add, OperatorIds.substract, OperatorIds.divide].includes((leftChild as OperatorNode).id))
+//               leftTex = `(${leftTex})`;
+//           }
+//           let needBrackets = rightTex[0] === "-";
+//           if (rightChild.type === NodeType.operator) {
+//             const operatorRightChild = rightChild as OperatorNode;
+//             needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorRightChild.id);
+//           }
+//           if (needBrackets) rightTex = `(${rightTex})`;
+//           //  permet de gérer le cas 3*2^x
+//           let showTimesSign = !isNaN(+rightTex[0]) || rightChild.type === NodeType.number;
+//           if (rightChild.type === NodeType.operator) {
+//             const operatorRightChild = rightChild as OperatorNode;
+//             showTimesSign ||= [OperatorIds.fraction].includes(operatorRightChild.id);
+//           }
+//           return `${leftTex}${showTimesSign ? "\\times " : ""}${rightTex}`;
+//         }
+//         case OperatorIds.divide: {
+//           if (leftChild.type === NodeType.operator) {
+//             if ([OperatorIds.add, OperatorIds.substract, OperatorIds.multiply].includes((leftChild as OperatorNode).id))
+//               leftTex = `(${leftTex})`;
+//           }
+//           let needBrackets = rightTex[0] === "-";
+//           if (rightChild.type === NodeType.operator) {
+//             const operatorRightChild = rightChild as OperatorNode;
+//             needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorRightChild.id);
+//           }
+//           if (needBrackets) rightTex = `(${rightTex})`;
+//           return `${leftTex} \\div ${rightTex}`;
+//         }
+//         case OperatorIds.fraction: {
+//           return `\\frac{${leftTex}}{${rightTex}}`;
+//         }
+//         case OperatorIds.power: {
+//           let needBrackets = leftTex[0] === "-";
+//           if (leftChild.type === NodeType.operator) {
+//             const childOperator = leftChild as OperatorNode;
+//             needBrackets ||= [
+//               OperatorIds.add,
+//               OperatorIds.substract,
+//               OperatorIds.multiply,
+//               OperatorIds.divide,
+//               OperatorIds.fraction,
+//               OperatorIds.power,
+//             ].includes(childOperator.id);
+//           }
+//           if (needBrackets) leftTex = `(${leftTex})`;
+//           return `${leftTex}^{${rightTex}}`;
+//         }
+//         case OperatorIds.equal: {
+//           return `${leftTex} = ${rightTex}`;
+//         }
+//         default:
+//           return node.tex;
+//       }
+//     case NodeType.function: {
+//       const functionNode = node as FunctionNode;
+//       const child = functionNode.child;
+//       let childTex = latexParser(functionNode.child);
+//       switch (functionNode.id) {
+//         case FunctionsIds.sqrt: {
+//           return `\\sqrt{${childTex}}`;
+//         }
+//         case FunctionsIds.opposite: {
+//           let needBrackets = childTex[0] === "-";
+//           if (child.type === NodeType.operator) {
+//             const operatorChild = child as OperatorNode;
+//             needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorChild.id);
+//           }
+//           if (needBrackets) childTex = `(${childTex})`;
+//           return `-${childTex}`;
+//         }
+//       }
+//     }
+//     default:
+//       return "";
+//   }
+// }

package/lib/tree/parsers/simplify.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simplifyNode = void 0;
+const mathjs_1 = require("mathjs");
+const oppositeNode_1 = require("../nodes/functions/oppositeNode");
+const sqrtNode_1 = require("../nodes/functions/sqrtNode");
+const numberNode_1 = require("../nodes/numbers/numberNode");
+const addNode_1 = require("../nodes/operators/addNode");
+const fractionNode_1 = require("../nodes/operators/fractionNode");
+const multiplyNode_1 = require("../nodes/operators/multiplyNode");
+const powerNode_1 = require("../nodes/operators/powerNode");
+const substractNode_1 = require("../nodes/operators/substractNode");
+const variableNode_1 = require("../nodes/variables/variableNode");
+const simplifyNode = (node) => {
+    console.log(node.toMathString());
+    return mathjsNodeToNode((0, mathjs_1.simplify)(node.toMathString()));
+};
+exports.simplifyNode = simplifyNode;
+const mathjsNodeToNode = (mathjsNode) => {
+    console.log(mathjsNode);
+    if (mathjsNode.isSymbolNode) {
+        return new variableNode_1.VariableNode(mathjsNode.name);
+    }
+    else if (mathjsNode.isConstantNode) {
+        return new numberNode_1.NumberNode(mathjsNode.value);
+    }
+    else if (mathjsNode.isOperatorNode) {
+        switch (mathjsNode.fn) {
+            case 'add':
+                return new addNode_1.AddNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
+            case 'substract':
+                return new substractNode_1.SubstractNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
+            case 'unaryMinus':
+                return new oppositeNode_1.OppositeNode(mathjsNodeToNode(mathjsNode.args[0]));
+            case 'divide':
+                return new fractionNode_1.FractionNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
+            case 'multiply':
+                return new multiplyNode_1.MultiplyNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
+            case 'pow':
+                return new powerNode_1.PowerNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
+        }
+    }
+    else if (mathjsNode.isFunctionNode) {
+        const fn = mathjsNode.fn;
+        switch (fn.name) {
+            case 'sqrt':
+                return new sqrtNode_1.SqrtNode(mathjsNodeToNode(mathjsNode.args[0]));
+        }
+    }
+    throw Error('unrecognized mathjs node');
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "1.2.10",
+  "version": "1.3.0",
   "description": "Générateurs d'exercices et questions mathématiques en latex",
   "main": "src/index.js",
   "files": [
@@ -31,5 +31,8 @@
   "bugs": {
     "url": "https://github.com/krirkrirk/math-exercices/issues"
   },
-  "homepage": "https://github.com/krirkrirk/math-exercices#readme"
+  "homepage": "https://github.com/krirkrirk/math-exercices#readme",
+  "dependencies": {
+    "mathjs": "^11.5.1"
+  }
 }