mathai 0.6.6__tar.gz → 0.6.8__tar.gz

{mathai-0.6.6 → mathai-0.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.6.6
+Version: 0.6.8
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai4
 Author: educated indians are having a low iq and are good for nothing

{mathai-0.6.6 → mathai-0.6.8}/mathai/base.py

@@ -1,5 +1,7 @@
 import copy
 from fractions import Fraction
+def use(eq):
+    return TreeNode(eq.name, [use(child) for child in eq.children])
 def contains_list_or_neg(node):
     stack = [node]
     while stack:

mathai-0.6.8/mathai/expand.py

@@ -0,0 +1,129 @@
+import itertools
+from .base import *
+from .simplify import simplify
+'''
+def _expand(equation):
+    eq = equation
+    eq.children = [_expand(flatten_tree(child)) for child in eq.children]
+    if eq.name == "f_pow":
+        n = frac(eq.children[1])
+        if n is not None and n.denominator == 1 and n.numerator > 1:
+            power_children = []
+            for i in range(n.numerator):
+                power_children.append(eq.children[0])
+            return _expand(flatten_tree(TreeNode("f_mul", power_children)))
+    if eq.name == "f_mul":
+        lone_children = tree_form("d_1")
+        bracket_children = []
+        for i in range(len(eq.children)-1,-1,-1):
+            if eq.children[i].name == "f_add":
+                bracket_children.append(eq.children[i])
+            elif eq.children[i].name == "f_pow" and eq.children[i].children[0].name == "f_add":
+                n = frac(eq.children[i].children[1])
+                if n is not None and n.denominator == 1 and n.numerator > 1:
+                    for j in range(n.numerator):
+                        bracket_children.append(eq.children[i].children[0])
+                else:
+                    lone_children = lone_children * eq.children[i]
+            else:
+                lone_children = lone_children * eq.children[i]
+        lone_children = simplify(lone_children)
+        while bracket_children != []:
+            tmp = tree_form("d_0")
+            for i in range(len(bracket_children[0].children)):
+                if lone_children.name == "f_add":
+                    for j in range(len(lone_children.children)):
+                        tmp = tmp + bracket_children[0].children[i] * lone_children.children[j]
+                else:
+                    tmp = tmp + lone_children * bracket_children[0].children[i]
+            lone_children = flatten_tree(simplify(tmp))
+            bracket_children.pop(0)
+        return lone_children
+    return eq
+'''
+def is_expandable(child):
+    if child.name == "f_add":
+        return True
+    if child.name == "f_pow" and child.children[0].name == "f_add":
+        n = frac(child.children[1])
+        return n is not None and n.denominator == 1 and n.numerator > 1
+    return False
+
+
+def expand_terms(child):
+    if child.name == "f_add":
+        return child.children
+    n = frac(child.children[1]).numerator
+    return child.children[0].children * n
+
+
+def _expand(equation):
+    stack = [(equation, 0, [])]
+
+    while stack:
+        node, idx, done = stack.pop()
+
+        if idx >= len(node.children):
+            node.children = done
+
+            # ===== f_pow =====
+            if node.name == "f_pow":
+                n = frac(node.children[1])
+                if n and n.denominator == 1 and n.numerator > 1:
+                    node = flatten_tree(
+                        TreeNode("f_mul", [node.children[0]] * n.numerator)
+                    )
+                    stack.append((node, 0, []))
+                    continue
+
+            # ===== f_mul =====
+            elif node.name == "f_mul":
+                children = node.children
+                k = len(children)
+
+                # ---- find expandable index (L→R, then R→L) ----
+                idxs = list(range(k)) + list(reversed(range(k)))
+                seen = set()
+                expand_i = None
+
+                for i in idxs:
+                    if i in seen:
+                        continue
+                    seen.add(i)
+                    if is_expandable(children[i]):
+                        expand_i = i
+                        break
+
+                if expand_i is not None:
+                    left = children[:expand_i]
+                    right = children[expand_i + 1:]
+                    expandable = children[expand_i]
+
+                    out = tree_form("d_0")
+                    for term in expand_terms(expandable):
+                        prod = term
+                        for r in right:
+                            prod = prod * r
+                        for l in reversed(left):
+                            prod = l * prod
+                        out = out + prod
+
+                    node = flatten_tree(simplify(out))
+
+            # ===== return =====
+            if stack:
+                parent, pidx, acc = stack.pop()
+                acc.append(node)
+                stack.append((parent, pidx + 1, acc))
+            else:
+                return node
+
+        else:
+            stack.append((node, idx, done))
+            child = flatten_tree(node.children[idx])
+            stack.append((child, 0, []))
+
+def expand(eq):
+    if TreeNode.matmul == True:
+        eq = tree_form(str_form(eq).replace("f_wmul", "f_mul"))
+    return _expand(eq)

{mathai-0.6.6 → mathai-0.6.8}/mathai/matrix.py

@@ -70,6 +70,10 @@ def contains_neg(node):
     return True
 # ---------- multiplication (fully simplified) ----------
 def multiply(left,right):
+    if left == tree_form("d_1"):
+        return right
+    if right == tree_form("d_1"):
+        return left
     left2, right2 = left, right
     if left2.name != "f_pow":
         left2 = left2 ** 1
@@ -217,7 +221,8 @@ def use(eq):
 def _matrix_solve(eq):
     if TreeNode.matmul == True:
         TreeNode.matmul = False
-        eq = flat(fold_wmul(flat(eq)))
+        eq = use(eq)
+        eq = dowhile(eq, lambda x: fold_wmul(flat(x)))
         TreeNode.matmul = True
     return eq
 def matrix_solve(eq):

{mathai-0.6.6 → mathai-0.6.8}/mathai/parser.py

@@ -152,11 +152,12 @@ def parse(equation, funclist=None):
             return tree_form("v_" + str(int(tree_node.name[3:])+100))
         tree_node.children = [rfx(child) for child in tree_node.children]
         return tree_node
+    
     tree_node = rfx(tree_node)
     tree_node = flatten_tree(tree_node, ["f_wmul"])
     if TreeNode.matmul == True:
         TreeNode.matmul = False
-        tree_node = tree_form(str_form(tree_node).replace("f_w","f_"))
+        tree_node = use(tree_form(str_form(tree_node).replace("f_w","f_")))
         TreeNode.matmul = True
     else:
         tree_node = tree_form(str_form(tree_node).replace("f_w","f_"))

{mathai-0.6.6 → mathai-0.6.8}/mathai/simplify.py

@@ -503,6 +503,8 @@ def simplify(eq, basic=True):
     orig = TreeNode.matmul
     if TreeNode.matmul == True:
         TreeNode.matmul = False
+        eq = use(tree_form(str_form(eq).replace("f_w","f_")))
+        
     if eq.name == "f_and" or eq.name == "f_not" or eq.name == "f_or":
         new_children = []
         for child in eq.children:

{mathai-0.6.6 → mathai-0.6.8}/mathai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.6.6
+Version: 0.6.8
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai4
 Author: educated indians are having a low iq and are good for nothing

{mathai-0.6.6 → mathai-0.6.8}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="mathai",
-    version="0.6.6",
+    version="0.6.8",
     description="Mathematics solving Ai tailored to NCERT",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",

mathai-0.6.6/mathai/expand.py

@@ -1,124 +0,0 @@
-import itertools
-from .base import *
-from .simplify import simplify
-'''
-def _expand(equation):
-    eq = equation
-    eq.children = [_expand(flatten_tree(child)) for child in eq.children]
-    if eq.name == "f_pow":
-        n = frac(eq.children[1])
-        if n is not None and n.denominator == 1 and n.numerator > 1:
-            power_children = []
-            for i in range(n.numerator):
-                power_children.append(eq.children[0])
-            return _expand(flatten_tree(TreeNode("f_mul", power_children)))
-    if eq.name == "f_mul":
-        lone_children = tree_form("d_1")
-        bracket_children = []
-        for i in range(len(eq.children)-1,-1,-1):
-            if eq.children[i].name == "f_add":
-                bracket_children.append(eq.children[i])
-            elif eq.children[i].name == "f_pow" and eq.children[i].children[0].name == "f_add":
-                n = frac(eq.children[i].children[1])
-                if n is not None and n.denominator == 1 and n.numerator > 1:
-                    for j in range(n.numerator):
-                        bracket_children.append(eq.children[i].children[0])
-                else:
-                    lone_children = lone_children * eq.children[i]
-            else:
-                lone_children = lone_children * eq.children[i]
-        lone_children = simplify(lone_children)
-        while bracket_children != []:
-            tmp = tree_form("d_0")
-            for i in range(len(bracket_children[0].children)):
-                if lone_children.name == "f_add":
-                    for j in range(len(lone_children.children)):
-                        tmp = tmp + bracket_children[0].children[i] * lone_children.children[j]
-                else:
-                    tmp = tmp + lone_children * bracket_children[0].children[i]
-            lone_children = flatten_tree(simplify(tmp))
-            bracket_children.pop(0)
-        return lone_children
-    return eq
-'''
-def _expand(equation):
-    """Iterative version of _expand without recursion."""
-    # Stack: (node, child_index, partially_processed_children)
-    stack = [(equation, 0, [])]
-
-    while stack:
-        node, child_index, processed_children = stack.pop()
-
-        # If all children are processed
-        if child_index >= len(node.children):
-            # Replace children with processed versions
-            node.children = processed_children
-
-            # === Handle f_pow ===
-            if node.name == "f_pow":
-                n = frac(node.children[1])
-                if n is not None and n.denominator == 1 and n.numerator > 1:
-                    # Convert power to repeated multiplication
-                    power_children = [node.children[0] for _ in range(n.numerator)]
-                    new_node = TreeNode("f_mul", power_children)
-                    # Flatten tree
-                    node = flatten_tree(new_node)
-                    # Push it back for further processing
-                    stack.append((node, 0, []))
-                    continue
-
-            # === Handle f_mul ===
-            elif node.name == "f_mul":
-                # Separate lone children and bracket children
-                lone_children = tree_form("d_1")
-                bracket_children = []
-
-                # Iterate in reverse (like original)
-                for child in reversed(node.children):
-                    if child.name == "f_add":
-                        bracket_children.append(child)
-                    elif child.name == "f_pow" and child.children[0].name == "f_add":
-                        n = frac(child.children[1])
-                        if n is not None and n.denominator == 1 and n.numerator > 1:
-                            for _ in range(n.numerator):
-                                bracket_children.append(child.children[0])
-                        else:
-                            lone_children = lone_children * child
-                    else:
-                        lone_children = lone_children * child
-
-                lone_children = simplify(lone_children)
-
-                # Distribute bracket children over lone children iteratively
-                while bracket_children:
-                    tmp = tree_form("d_0")
-                    bracket = bracket_children.pop(0)
-                    for bc in bracket.children:
-                        if lone_children.name == "f_add":
-                            for lc in lone_children.children:
-                                tmp = tmp + bc * lc
-                        else:
-                            tmp = tmp + bc * lone_children
-                    # Simplify after each distribution
-                    lone_children = flatten_tree(simplify(tmp))
-
-                node = lone_children
-
-            # === Return node to parent ===
-            if stack:
-                parent, idx, parent_children = stack.pop()
-                parent_children.append(node)
-                stack.append((parent, idx + 1, parent_children))
-            else:
-                # Root node fully expanded
-                return node
-
-        else:
-            # Push current node back for next child
-            stack.append((node, child_index, processed_children))
-            # Push the child to process next
-            child = flatten_tree(node.children[child_index])
-            stack.append((child, 0, []))
-
-def expand(eq):
-    return _expand(eq)