mathai 0.6.6__py3-none-any.whl → 0.6.8__py3-none-any.whl

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/expand.py

@@ -41,84 +41,89 @@ def _expand(equation):
         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):
-    """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()
+        node, idx, done = stack.pop()
 
-        # If all children are processed
-        if child_index >= len(node.children):
-            # Replace children with processed versions
-            node.children = processed_children
+        if idx >= len(node.children):
+            node.children = done
 
-            # === Handle f_pow ===
+            # ===== 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
+                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
 
-            # === Handle f_mul ===
+            # ===== 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 ===
+                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, idx, parent_children = stack.pop()
-                parent_children.append(node)
-                stack.append((parent, idx + 1, parent_children))
+                parent, pidx, acc = stack.pop()
+                acc.append(node)
+                stack.append((parent, pidx + 1, acc))
             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((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/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/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/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.dist-info → mathai-0.6.8.dist-info}/METADATA

@@ -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.dist-info → mathai-0.6.8.dist-info}/RECORD

@@ -1,10 +1,10 @@
 mathai/__init__.py,sha256=gzddzgNCG3Bg5BnqrDYvO71SzK4hu9fbo4nGEaDaG5Q,1554
 mathai/apart.py,sha256=VSS3khE9PNuxiRvdU5JDl4IN-KJBSIFjwR17pkhviXI,4197
-mathai/base.py,sha256=ZC_gte6LhqvMFvIV1R1JWS_-ZkVhEpt_Zeot4IWJ-XQ,15572
+mathai/base.py,sha256=9TfeBem7rrPwuJAEhrD-a5Mqzd9a0z-5aDa90Sl6LHg,15655
 mathai/bivariate_inequality.py,sha256=Da-A1kqVynR0tNOlEI7GSTf5T2vNkcF4etL9-EoyPJg,11415
 mathai/console.py,sha256=Sn58iwYE79MLEh67s8X3q6vZjw6g7f9XM1T8_dBBR2o,3048
 mathai/diff.py,sha256=RSTwlfeddvYXUDShCeRdcPjsmAS8Vf5OkYJAaUBPaiM,3060
-mathai/expand.py,sha256=chf5Ht6jLWNZl_RB_hziI7u_ZwsRtCGWJropt88dPA4,5474
+mathai/expand.py,sha256=Bh9slVYXV9OAPSpTyuFWKVlJXqnN4eAF2z6y6MFjdGo,4799
 mathai/factor.py,sha256=4NF2xep0TpS307Z8WaFGmVSjfDGjlpLUuzFJAJKjJn4,12522
 mathai/fraction.py,sha256=88xvRpDGfFi8tbe1QIyejdSP91HcErrN4VS2MxzbhrY,4392
 mathai/integrate.py,sha256=C_lqYgQN4UiriCb_LDkpwtKx7XJhp_K8T9skCkxWqas,17208
@@ -12,17 +12,17 @@ mathai/inverse.py,sha256=ya7P8WjzfaAL3UXL7xqOh5GaIsXLDZ-F6lZFy3IEgaQ,2931
 mathai/limit.py,sha256=9F8i9UZh2xb-V8A5Sd1gdhDf9c2RFgpE1GdNn9MvbWI,5703
 mathai/linear.py,sha256=viGlPU8BPrjLWHlyNUvnfPHNH5d4ZBImiQMdyXaKGg0,5702
 mathai/logic.py,sha256=Ndz4Fd6aNCmzFlqoPyyIpSmV_BXmYHsurePjLyZJoNc,9809
-mathai/matrix.py,sha256=hsgcD7JYbgvZ8pey-YoT8oaEHdO-qmu8ICJcc6_4Ckc,7155
+mathai/matrix.py,sha256=05GEi6K3hyu3UP_CFZfPnwDVIB52YGmlzCtCoZPh_iw,7305
 mathai/ode.py,sha256=zxxTXAOpt7oSsfpgI4vHsCWKXevmM96ZOBZWWs-vj8Y,4801
-mathai/parser.py,sha256=YzXCW5MmwL3J0BhR0ZrPS2wnfz77uB_enBXPjITc-a0,7303
+mathai/parser.py,sha256=nEAdSSJeapBOhvjbkXJFtCEBU8izajXZAITV8rbslic,7314
 mathai/parsetab.py,sha256=TL-4jvRM_Tx6ipwet8CFJc2DkjR4tGsbrGF_r4IC8xI,9651
 mathai/printeq.py,sha256=MKsR6-qXig80R07vLnFPYHQMeS41FrMVj3n3arrhJpQ,1329
-mathai/simplify.py,sha256=NxcyEAA85FGQ2plj13EYmR5LcKmeGGLP6v8wZBs60JQ,19723
+mathai/simplify.py,sha256=J4M81rOuzgOrRElKAFR1dx1BD7zK2CfmgdWw8z-az2w,19796
 mathai/structure.py,sha256=wrU7kqphSN7CqaVffyHHXD2-3t5My_Z_TtYFoUe_lTU,4099
 mathai/tool.py,sha256=ozcXTXLbKUnyPM9r9kz9M43YA2CBcWezcqLZfEs8rpc,6051
 mathai/trig.py,sha256=fnBbfiopcQzFg4ya1BoO5M0X_aCBnse2bjnKh1juw4I,11223
 mathai/univariate_inequality.py,sha256=LPFdWgC1y5zBwnsy1wwZxj-yP_SbqFDhCmTTzhuwoiY,16469
-mathai-0.6.6.dist-info/METADATA,sha256=WYwBYgQZx30E6z7ROkHiXkz_g-cDxV_956i0P6TwPjk,7103
-mathai-0.6.6.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-mathai-0.6.6.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
-mathai-0.6.6.dist-info/RECORD,,
+mathai-0.6.8.dist-info/METADATA,sha256=qlUlg0g6-rOvYKNeanb7r4GDXdsOJYuN6qP_Jrd94gY,7103
+mathai-0.6.8.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+mathai-0.6.8.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
+mathai-0.6.8.dist-info/RECORD,,