mathai 0.6.3__tar.gz → 0.6.5__tar.gz

{mathai-0.6.3 → mathai-0.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.6.3
+Version: 0.6.5
 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.3 → mathai-0.6.5}/mathai/base.py

@@ -1,11 +1,12 @@
 import copy
 from fractions import Fraction
 def contains_list_or_neg(node):
-    if node.name == "f_list" or node.name.startswith("v_-"):
-        return True
-    for child in node.children:
-        if contains_list_or_neg(child):
+    stack = [node]
+    while stack:
+        n = stack.pop()
+        if n.name == "f_list" or n.name.startswith("v_-"):
             return True
+        stack.extend(n.children)
     return False
 class TreeNode:
     matmul = None
@@ -30,28 +31,32 @@ class TreeNode:
                     sortable.append(c)
                 else:
                     fixed.append(c)
+                    
+            if len(sortable) > 1:
+                sortable = TreeNode("f_dmul", list(sorted(sortable, key=lambda x: str_form(x))))
+                sortable.name = "f_mul"
+                
+            elif len(sortable) == 1:
+                sortable = sortable[0]
+                
+            if isinstance(sortable, TreeNode):
+                fixed.append(sortable)
             if len(fixed) > 1:
-                fixed = TreeNode("f_wmul", fixed)
+                self.name = "f_wmul"
             elif len(fixed) == 1:
-                fixed = fixed[0]
-            if isinstance(fixed, TreeNode):
-                sortable.append(fixed)
-            if len(sortable)==1 and name == "f_mul":
-                self.name = sortable[0].name
-                if self.name in ["f_add", "f_mul"]:
-                    self.children = list(sorted(sortable[0].children, key=lambda x: str_form(x)))
-                else:
-                    self.children = sortable[0].children
+                self.name = fixed[0].name
+                fixed = fixed[0].children
                 
-            else:
-                self.children = list(sorted(sortable, key=lambda x: str_form(x)))
+                
+            self.children = fixed
         else:
             self.children = children
 
 
     def fx(self, fxname):
         return TreeNode("f_" + fxname, [self])
-
+    def copy_tree(self):
+        return copy.deepcopy(self)
     def __repr__(self):
         return string_equation(str_form(self))
 

mathai-0.6.5/mathai/matrix.py

@@ -0,0 +1,224 @@
+from .base import *
+import copy
+from .simplify import simplify
+import itertools
+
+# ---------- tree <-> python list ----------
+def tree_to_py(node):
+    if node.name=="f_list":
+        return [tree_to_py(c) for c in node.children]
+    return node
+
+def py_to_tree(obj):
+    if isinstance(obj,list):
+        return TreeNode("f_list",[py_to_tree(x) for x in obj])
+    return obj
+
+# ---------- shape detection ----------
+def is_vector(x):
+    return isinstance(x,list) and all(isinstance(item,TreeNode) for item in x)
+def is_mat(x):
+    return isinstance(x,list) and all(isinstance(item,list) for item in x)
+def is_matrix(x):
+    return isinstance(x, list) and all(isinstance(item, list) and (is_mat(item) or is_vector(item)) for item in x)
+           
+
+# ---------- algebra primitives ----------
+def dot(u,v):
+    if len(u)!=len(v):
+        raise ValueError("Vector size mismatch")
+    s = tree_form("d_0")
+    for a,b in zip(u,v):
+        s = TreeNode("f_add",[s,TreeNode("f_mul",[a,b])])
+    return s
+
+def matmul(A, B):
+    # A: n × m
+    # B: m × p
+    
+    n = len(A)
+    m = len(A[0])
+    p = len(B[0])
+
+    if m != len(B):
+        raise ValueError("Matrix dimension mismatch")
+
+    C = [[tree_form("d_0") for _ in range(p)] for _ in range(n)]
+
+    for i in range(n):
+        for j in range(p):
+            for k in range(m):
+                C[i][j] = TreeNode(
+                    "f_add",
+                    [C[i][j], TreeNode("f_mul", [A[i][k], B[k][j]])]
+                )
+    return C
+
+# ---------- promotion ----------
+def promote(node):
+    if node.name=="f_list":
+        return tree_to_py(node)
+    return node
+def contains_neg(node):
+    if isinstance(node, list):
+        return False
+    if node.name.startswith("v_-"):
+        return False
+    for child in node.children:
+        if not contains_neg(child):
+            return False
+    return True
+# ---------- multiplication (fully simplified) ----------
+def multiply(left,right):
+    left2, right2 = left, right
+    if left2.name != "f_pow":
+        left2 = left2 ** 1
+    if right2.name != "f_pow":
+        right2 = right2 ** 1
+    if left2.name == "f_pow" and right2.name == "f_pow" and left2.children[0]==right2.children[0]:
+        return simplify(left2.children[0]**(left2.children[1]+right2.children[1]))
+    A,B = promote(left), promote(right)
+
+    # vector · vector
+    if is_vector(A) and is_vector(B):
+        return dot(A,B)
+    # matrix × matrix
+    if is_matrix(A) and is_matrix(B):
+        return py_to_tree(matmul(A,B))
+    # scalar × vector
+    for _ in range(2):
+        if contains_neg(A) and is_vector(B):
+            return py_to_tree([TreeNode("f_mul",[A,x]) for x in B])
+        # scalar × matrix
+        if contains_neg(A) and is_matrix(B):
+            return py_to_tree([[TreeNode("f_mul",[A,x]) for x in row] for row in B])
+        A, B = B, A
+    return None
+def add_vec(A, B):
+    if len(A) != len(B):
+        raise ValueError("Vector dimension mismatch")
+
+    return [
+        TreeNode("f_add", [A[i], B[i]])
+        for i in range(len(A))
+    ]
+def matadd(A, B):
+    if len(A) != len(B) or len(A[0]) != len(B[0]):
+        raise ValueError("Matrix dimension mismatch")
+
+    n = len(A)
+    m = len(A[0])
+
+    return [
+        [
+            TreeNode("f_add", [A[i][j], B[i][j]])
+            for j in range(m)
+        ]
+        for i in range(n)
+    ]
+def addition(left,right):
+    A,B = promote(left), promote(right)
+    # vector + vector
+    if is_vector(A) and is_vector(B):
+        return add_vec(A,B)
+    # matrix + matrix
+    if is_matrix(A) and is_matrix(B):
+        return py_to_tree(matadd(A,B))
+    return None
+'''
+def fold_wmul(eq):
+    if eq.name == "f_pow" and eq.children[1].name.startswith("d_"):
+        n = int(eq.children[1].name[2:])
+        if n == 1:
+            eq = eq.children[0]
+        elif n > 1:
+            tmp = promote(eq.children[0])
+            if is_matrix(tmp):
+                orig =tmp
+                for i in range(n-1):
+                    tmp = matmul(orig, tmp)
+                eq = py_to_tree(tmp)
+    elif eq.name in ["f_wmul", "f_add"]:
+        if len(eq.children) == 1:
+            eq = eq.children[0]
+        else:
+            i = len(eq.children)-1
+            while i>0:
+                if eq.name == "f_wmul":
+                    out = multiply(eq.children[i-1], eq.children[i])
+                else:
+                    out = addition(eq.children[i-1], eq.children[i])
+                if out is not None:
+                    eq.children.pop(i)
+                    eq.children.pop(i-1)
+                    eq.children.insert(i-1,out)
+                i = i-1
+    return TreeNode(eq.name, [fold_wmul(child) for child in eq.children])
+'''
+def fold_wmul(root):
+    # Post-order traversal using explicit stack
+    stack = [(root, False)]
+    newnode = {}
+
+    while stack:
+        node, visited = stack.pop()
+
+        if not visited:
+            # First time: push back as visited, then children
+            stack.append((node, True))
+            for child in node.children:
+                stack.append((child, False))
+        else:
+            # All children already processed
+            children = [newnode[c] for c in node.children]
+            eq = TreeNode(node.name, children)
+
+            # ---- original rewrite logic ----
+
+            if eq.name == "f_pow" and eq.children[1].name.startswith("d_"):
+                n = int(eq.children[1].name[2:])
+                if n == 1:
+                    eq = eq.children[0]
+                elif n > 1:
+                    tmp = promote(eq.children[0])
+                    if is_matrix(tmp):
+                        orig = tmp
+                        for _ in range(n - 1):
+                            tmp = matmul(orig, tmp)
+                        eq = py_to_tree(tmp)
+
+            elif eq.name in ["f_wmul", "f_add"]:
+                if len(eq.children) == 1:
+                    eq = eq.children[0]
+                else:
+                    i = len(eq.children) - 1
+                    while i > 0:
+                        if eq.name == "f_wmul":
+                            out = multiply(eq.children[i - 1], eq.children[i])
+                        else:
+                            out = addition(eq.children[i - 1], eq.children[i])
+
+                        if out is not None:
+                            eq.children.pop(i)
+                            eq.children.pop(i - 1)
+                            eq.children.insert(i - 1, out)
+                        i -= 1
+
+            # --------------------------------
+
+            newnode[node] = eq
+
+    return newnode[root]
+
+def flat(eq):
+    return flatten_tree(eq, ["f_wmul"])
+def use(eq):
+    return TreeNode(eq.name, [use(child) for child in eq.children])
+def _matrix_solve(eq):
+    if TreeNode.matmul == True:
+        TreeNode.matmul = False
+        eq = flat(dowhile(eq, lambda x: fold_wmul(flat(x))))
+        TreeNode.matmul = True
+    return eq
+def matrix_solve(eq):
+    return _matrix_solve(eq)

{mathai-0.6.3 → mathai-0.6.5}/mathai/parser.py

@@ -158,4 +158,6 @@ def parse(equation, funclist=None):
         TreeNode.matmul = False
         tree_node = 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_"))
     return tree_node

{mathai-0.6.3 → mathai-0.6.5}/mathai/simplify.py

@@ -20,7 +20,6 @@ def clear_div(eq, denom):
         return tree_form("d_0"), True
     lst3 = []
     for item in lst:
-        print(str_form(item))
         if "v_" not in str_form(item) and compute(item) < 0:
             lst3.append(item)
     sign = denom

{mathai-0.6.3 → mathai-0.6.5}/mathai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.6.3
+Version: 0.6.5
 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.3 → mathai-0.6.5}/setup.py

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

mathai-0.6.3/mathai/matrix.py

@@ -1,101 +0,0 @@
-from .base import *
-import copy
-from .simplify import simplify
-import itertools
-
-# ---------- tree <-> python list ----------
-def tree_to_py(node):
-    if node.name=="f_list":
-        return [tree_to_py(c) for c in node.children]
-    return node
-
-def py_to_tree(obj):
-    if isinstance(obj,list):
-        return TreeNode("f_list",[py_to_tree(x) for x in obj])
-    return obj
-
-# ---------- shape detection ----------
-def is_vector(x):
-    return isinstance(x,list) and all(isinstance(item,TreeNode) for item in x)
-def is_mat(x):
-    return isinstance(x,list) and all(isinstance(item,list) for item in x)
-def is_matrix(x):
-    return isinstance(x, list) and all(isinstance(item, list) and (is_mat(item) or is_vector(item)) for item in x)
-           
-
-# ---------- algebra primitives ----------
-def dot(u,v):
-    if len(u)!=len(v):
-        raise ValueError("Vector size mismatch")
-    s = tree_form("d_0")
-    for a,b in zip(u,v):
-        s = TreeNode("f_add",[s,TreeNode("f_mul",[a,b])])
-    return s
-
-def matmul(A,B):
-    n,m,p = len(A), len(A[0]), len(B[0])
-    if m!=len(B):
-        raise ValueError("Matrix dimension mismatch")
-    z = tree_form("d_0")
-    C = [[z for _ in range(p)] for _ in range(n)]
-    for i in range(n):
-        for j in range(p):
-            for k in range(m):
-                C[i][j] = TreeNode("f_add",[C[i][j], TreeNode("f_mul",[A[i][k], B[k][j]])])
-    return C
-
-# ---------- promotion ----------
-def promote(node):
-    if node.name=="f_list":
-        return tree_to_py(node)
-    return node
-def contains_neg(node):
-    if isinstance(node, list):
-        return False
-    if node.name.startswith("v_-"):
-        return False
-    for child in node.children:
-        if not contains_neg(child):
-            return False
-    return True
-# ---------- multiplication (fully simplified) ----------
-def multiply(left,right):
-    A,B = promote(left), promote(right)
-
-    # vector · vector
-    if is_vector(A) and is_vector(B):
-        return dot(A,B)
-    # matrix × matrix
-    if is_matrix(A) and is_matrix(B):
-        return py_to_tree(matmul(A,B))
-    # scalar × vector
-    for _ in range(2):
-        if contains_neg(A) and is_vector(B):
-            return py_to_tree([TreeNode("f_mul",[A,x]) for x in B])
-        # scalar × matrix
-        if contains_neg(A) and is_matrix(B):
-            return py_to_tree([[TreeNode("f_mul",[A,x]) for x in row] for row in B])
-        A, B = B, A
-    return None
-
-def fold_wmul(eq):
-    if eq.name=="f_wmul" and any(item.name=="f_list" or item.name.startswith("v_-") for item in eq.children):
-        i = len(eq.children)-1
-        while i>0:
-            out = multiply(eq.children[i], eq.children[i-1])
-            if out is not None:
-                eq.children.pop(i)
-                eq.children.pop(i-1)
-                eq.children.append(out)
-            i = i-1
-        return eq
-    return TreeNode(eq.name, [fold_wmul(child) for child in eq.children])
-def flat(eq):
-    return flatten_tree(tree_form(str_form(eq).replace("f_w","f_")))
-def matrix_solve(eq):
-    if TreeNode.matmul == True:
-        TreeNode.matmul = False
-        eq = simplify(eq)
-        eq = flat(dowhile(eq, lambda x: fold_wmul(flat(x))))
-        TreeNode.matmul = True
-    return eq