math-exercises 1.2.4 → 1.2.5

package/src/tree/parsers/derivateParser.ts

@@ -0,0 +1,66 @@
+import { Node, NodeType } from "../nodes/node";
+import { NumberNode } from "../nodes/numbers/numberNode";
+import { PowerNode } from "../nodes/operators/powerNode";
+
+import { AddNode } from "../nodes/operators/addNode";
+import { FractionNode } from "../nodes/operators/fractionNode";
+import { MultiplyNode } from "../nodes/operators/multiplyNode";
+import { OperatorIds, OperatorNode } from "../nodes/operators/operatorNode";
+import { SubstractNode } from "../nodes/operators/substractNode";
+import { FunctionNode, FunctionsIds } from "../nodes/functions/functionNode";
+import { SqrtNode } from "../nodes/functions/sqrtNode";
+import { OppositeNode } from "../nodes/functions/oppositeNode";
+
+export function derivateParser(node: Node): Node {
+  if (!node) throw Error("encountered a null node ??");
+
+  switch (node.type) {
+    case NodeType.variable:
+      return new NumberNode(1);
+    case NodeType.number:
+      return new NumberNode(0);
+    case NodeType.operator:
+      const operatorNode = node as OperatorNode;
+      const u = operatorNode.leftChild;
+      const v = operatorNode.rightChild;
+      switch (operatorNode.id) {
+        case OperatorIds.add:
+          return new AddNode(derivateParser(u), derivateParser(v));
+        case OperatorIds.substract: {
+          return new SubstractNode(derivateParser(u), derivateParser(v));
+        }
+        case OperatorIds.multiply: {
+          return new AddNode(new MultiplyNode(derivateParser(u), v), new MultiplyNode(u, derivateParser(v)));
+        }
+        case OperatorIds.divide:
+        case OperatorIds.fraction:
+          return new FractionNode(
+            new SubstractNode(new MultiplyNode(derivateParser(u), v), new MultiplyNode(u, derivateParser(v))),
+            new PowerNode(v, new NumberNode(2))
+          );
+
+        case OperatorIds.power: {
+          const operatorNode = node as OperatorNode;
+          const n = operatorNode.rightChild as NumberNode;
+          const u = operatorNode.leftChild;
+          return new MultiplyNode(
+            n,
+            new MultiplyNode(derivateParser(u), new PowerNode(u, new NumberNode(n.value - 1)))
+          );
+        }
+      }
+    case NodeType.function: {
+      const functionNode = node as FunctionNode;
+      const child = functionNode.child;
+      switch (functionNode.id) {
+        case FunctionsIds.sqrt: {
+          return new FractionNode(derivateParser(child), new MultiplyNode(new NumberNode(2), new SqrtNode(child)));
+        }
+
+        case FunctionsIds.opposite: {
+          return new OppositeNode(derivateParser(child));
+        }
+      }
+    }
+  }
+}

package/src/tree/parsers/latexParser.js

@@ -0,0 +1,117 @@
+"use strict";
+exports.__esModule = true;
+exports.latexParser = void 0;
+var functionNode_1 = require("../nodes/functions/functionNode");
+var node_1 = require("../nodes/node");
+var 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:
+            var operatorNode = node;
+            var rightTex = latexParser(operatorNode.rightChild);
+            var leftTex = latexParser(operatorNode.leftChild);
+            var leftChild = operatorNode.leftChild, rightChild = operatorNode.rightChild;
+            switch (operatorNode.id) {
+                case operatorNode_1.OperatorIds.add:
+                    return "".concat(leftTex, " ").concat(rightTex[0] === "-" ? "" : "+ ").concat(rightTex);
+                case operatorNode_1.OperatorIds.substract: {
+                    var needBrackets = (rightChild.type === node_1.NodeType.operator &&
+                        [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(rightChild.id)) ||
+                        rightTex[0] === "-";
+                    if (needBrackets)
+                        rightTex = "(".concat(rightTex, ")");
+                    return "".concat(leftTex, " - ").concat(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 = "(".concat(leftTex, ")");
+                    }
+                    var needBrackets = rightTex[0] === "-";
+                    if (rightChild.type === node_1.NodeType.operator) {
+                        var operatorRightChild = rightChild;
+                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
+                    }
+                    if (needBrackets)
+                        rightTex = "(".concat(rightTex, ")");
+                    //  permet de gérer le cas 3*2^x
+                    var showTimesSign = !isNaN(+rightTex[0]) || rightChild.type === node_1.NodeType.number;
+                    if (rightChild.type === node_1.NodeType.operator) {
+                        var operatorRightChild = rightChild;
+                        showTimesSign || (showTimesSign = [operatorNode_1.OperatorIds.fraction].includes(operatorRightChild.id));
+                    }
+                    return "".concat(leftTex).concat(showTimesSign ? "\\times " : "").concat(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 = "(".concat(leftTex, ")");
+                    }
+                    var needBrackets = rightTex[0] === "-";
+                    if (rightChild.type === node_1.NodeType.operator) {
+                        var operatorRightChild = rightChild;
+                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
+                    }
+                    if (needBrackets)
+                        rightTex = "(".concat(rightTex, ")");
+                    return "".concat(leftTex, " \\div ").concat(rightTex);
+                }
+                case operatorNode_1.OperatorIds.fraction: {
+                    return "\\frac{".concat(leftTex, "}{").concat(rightTex, "}");
+                }
+                case operatorNode_1.OperatorIds.power: {
+                    var needBrackets = leftTex[0] === "-";
+                    if (leftChild.type === node_1.NodeType.operator) {
+                        var 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 = "(".concat(leftTex, ")");
+                    return "".concat(leftTex, "^{").concat(rightTex, "}");
+                }
+                case operatorNode_1.OperatorIds.equal: {
+                    return "".concat(leftTex, " = ").concat(rightTex);
+                }
+                default:
+                    return node.tex;
+            }
+        case node_1.NodeType["function"]: {
+            var functionNode = node;
+            var child = functionNode.child;
+            var childTex = latexParser(functionNode.child);
+            switch (functionNode.id) {
+                case functionNode_1.FunctionsIds.sqrt: {
+                    return "\\sqrt{".concat(childTex, "}");
+                }
+                case functionNode_1.FunctionsIds.opposite: {
+                    var needBrackets = childTex[0] === "-";
+                    if (child.type === node_1.NodeType.operator) {
+                        var operatorChild = child;
+                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorChild.id));
+                    }
+                    if (needBrackets)
+                        childTex = "(".concat(childTex, ")");
+                    return "-".concat(childTex);
+                }
+            }
+        }
+        default:
+            return "";
+    }
+}
+exports.latexParser = latexParser;

package/src/tree/{latexParser/latexParse.ts → parsers/latexParser.ts}

@@ -2,7 +2,7 @@ import { FunctionNode, FunctionsIds } from "../nodes/functions/functionNode";
 import { Node, NodeType } from "../nodes/node";
 import { OperatorIds, OperatorNode } from "../nodes/operators/operatorNode";
 
-export function latexParse(node: Node): string {
+export function latexParser(node: Node): string {
   if (!node) {
     console.log("parsing a null node ???");
     return "";
@@ -14,8 +14,8 @@ export function latexParse(node: Node): string {
       return node.tex;
     case NodeType.operator:
       const operatorNode = node as OperatorNode;
-      let rightTex = latexParse(operatorNode.rightChild);
-      let leftTex = latexParse(operatorNode.leftChild);
+      let rightTex = latexParser(operatorNode.rightChild);
+      let leftTex = latexParser(operatorNode.leftChild);
       const { leftChild, rightChild } = operatorNode;
       switch (operatorNode.id) {
         case OperatorIds.add:
@@ -99,7 +99,7 @@ export function latexParse(node: Node): string {
     case NodeType.function: {
       const functionNode = node as FunctionNode;
       const child = functionNode.child;
-      let childTex = latexParse(functionNode.child);
+      let childTex = latexParser(functionNode.child);
       switch (functionNode.id) {
         case FunctionsIds.sqrt: {
           return `\\sqrt{${childTex}}`;