mathai 0.6.7__tar.gz → 0.6.9__tar.gz

{mathai-0.6.7 → mathai-0.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.6.7
+Version: 0.6.9
 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.7 → mathai-0.6.9}/mathai/__init__.py

@@ -7,7 +7,7 @@ from .expand import expand
 
 from .parser import parse
 
-from .printeq import printeq, printeq_log, printeq_str
+from .printeq import printeq, printeq_str
 
 from .simplify import simplify
 

{mathai-0.6.7 → mathai-0.6.9}/mathai/base.py

@@ -1,5 +1,9 @@
 import copy
 from fractions import Fraction
+def use(eq):
+    return TreeNode(eq.name, [use(child) for child in eq.children])
+def use2(eq):
+    return use(tree_form(str_form(eq).replace("f_wmul", "f_mul")))
 def contains_list_or_neg(node):
     stack = [node]
     while stack:
@@ -8,9 +12,10 @@ def contains_list_or_neg(node):
             return True
         stack.extend(n.children)
     return False
+
 class TreeNode:
     matmul = None
-
+    
     def __init__(self, name, children=None):
         if children is None:
             children = []
@@ -245,7 +250,9 @@ def frac(eq):
 def factor_generation(eq):
     output = []
     if eq.name != "f_mul":
-        eq = TreeNode("f_mul", [eq])
+        tmp = TreeNode("f_mul", [])
+        tmp.children.append(eq)
+        eq = tmp
     if eq.name == "f_mul":
         for child in eq.children:
             if child.name == "f_pow":

mathai-0.6.9/mathai/expand.py

@@ -0,0 +1,95 @@
+from .base import *
+from .simplify import simplify
+import itertools
+
+def eliminate_powers(node):
+    if not node.children:
+        return node
+
+    node.children = [eliminate_powers(c) for c in node.children]
+
+    if node.name == "f_pow":
+        base, exp = node.children
+        n = frac(exp)
+
+        # Only expand positive integer powers
+        if not (n and n.denominator == 1 and n.numerator > 1):
+            return node
+
+        n = n.numerator
+
+        # ---- Multinomial expansion ----
+        if base.name == "f_add":
+            terms = []
+            for combo in itertools.product(base.children, repeat=n):
+                prod = combo[0]
+                for c in combo[1:]:
+                    prod = prod * c
+                terms.append(prod)
+            return simplify(TreeNode("f_add", terms))
+
+        # ---- Fallback: simple power ----
+        return TreeNode("f_mul", [base] * n)
+
+    return node
+
+
+
+# =====================================================
+# Phase 2: Single distributive rewrite (DEEPEST FIRST)
+# =====================================================
+
+def expand_once(node):
+    """
+    Performs exactly ONE distributive expansion.
+    Deepest-first (post-order).
+    """
+
+    # ---- recurse FIRST (this is the fix) ----
+    for i, c in enumerate(node.children):
+        new, changed = expand_once(c)
+        if changed:
+            node.children[i] = new
+            return node, True
+
+    # ---- now try expanding at this node ----
+    if node.name == "f_mul":
+        for i, child in enumerate(node.children):
+            if child.name == "f_add":
+                left = node.children[:i]
+                right = node.children[i+1:]
+
+                terms = []
+                for t in child.children:
+                    prod = t
+                    for r in right:
+                        prod = prod * r
+                    for l in reversed(left):
+                        prod = l * prod
+                    terms.append(prod)
+
+                return TreeNode("f_add", terms), True
+
+    return node, False
+
+
+# =====================================================
+# Phase 3: Global fixed-point driver
+# =====================================================
+
+def expand(eq):
+    orig = TreeNode.matmul
+    eq = simplify(eq)
+    if TreeNode.matmul is not None:
+        TreeNode.matmul = True
+        eq = tree_form(str_form(eq).replace("f_wmul", "f_mul"))
+        eq = flatten_tree(eq)
+    eq = eliminate_powers(eq)
+    while True:        
+        eq = flatten_tree(eq)        
+        eq, changed = expand_once(eq)
+        if not changed:
+            break
+    eq =simplify(eq)
+    TreeNode.matmul = orig
+    return eq

{mathai-0.6.7 → mathai-0.6.9}/mathai/factor.py

@@ -8,7 +8,7 @@ from .expand import expand
 import math
 from .tool import poly
 from .fraction import fraction
-from .printeq import printeq
+
 from collections import Counter
 def multiset_intersection(*lists):
     counters = list(map(Counter, lists))

{mathai-0.6.7 → mathai-0.6.9}/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,7 @@ def use(eq):
 def _matrix_solve(eq):
     if TreeNode.matmul == True:
         TreeNode.matmul = False
-        eq = dowhile(eq, lambda x: fold_wmul(flat(x)))
+        eq = dowhile(eq, lambda x: fold_wmul(use(flat(x))))
         TreeNode.matmul = True
     return eq
 def matrix_solve(eq):

{mathai-0.6.7 → mathai-0.6.9}/mathai/parser.py

@@ -152,8 +152,7 @@ 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
-    def use(eq):
-        return TreeNode(eq.name, [use(child) for child in eq.children])
+    
     tree_node = rfx(tree_node)
     tree_node = flatten_tree(tree_node, ["f_wmul"])
     if TreeNode.matmul == True:

{mathai-0.6.7 → mathai-0.6.9}/mathai/printeq.py

@@ -1,4 +1,5 @@
 from .base import *
+from .factor import merge_sqrt
 from .simplify import simplify
 import copy
 from fractions import Fraction
@@ -24,11 +25,13 @@ def abstractexpr(eq):
     return TreeNode(eq.name, [abstractexpr(child) for child in eq.children])
 
 def printeq_str(eq):
-    return str(dowhile(eq, abstractexpr))
+    if eq is None:
+        return None
+    eq = merge_sqrt(eq)
+    return string_equation(str_form(dowhile(eq, abstractexpr)))
+def printeq_obj(self):
+    return printeq_str(self)
 
 def printeq(eq):
     print(printeq_str(eq))
-
-def printeq_log(lst):
-    for item in lst:
-        print("  "*item[0] + item[1])
+TreeNode.__repr__ = printeq_obj

{mathai-0.6.7 → mathai-0.6.9}/mathai/simplify.py

@@ -15,9 +15,12 @@ def convert_to_basic(node):
     return node
 
 def clear_div(eq, denom):
+    
     lst = factor_generation(eq)
+    
     if tree_form("d_0") in lst:
         return tree_form("d_0"), True
+
     lst3 = []
     for item in lst:
         if "v_" not in str_form(item) and compute(item) < 0:
@@ -33,10 +36,12 @@ def clear_div(eq, denom):
                 eq2.append(item)
             else:
                 eq3.append(item)
+        
         if eq3 == []:
             return product(eq2), True
         return product(eq3), sign
     lst4 = []
+    
     for item in lst:
         if item.name == "f_pow":
             tmp = frac(item.children[1])
@@ -44,10 +49,12 @@ def clear_div(eq, denom):
                 lst4.append(item)
         else:
             lst4.append(item)
+    
     lst2 = []
     for item in lst4:
         if frac(item) is None:#"v_" in str_form(item):
             lst2.append(item)
+            
     if lst2 == []:
         return product(lst4), sign
     return product(lst2), sign
@@ -500,23 +507,34 @@ def solve3(eq):
 def simplify(eq, basic=True):
     if eq is None:
         return None
+    orig = TreeNode.matmul
+    if TreeNode.matmul == True:
+        TreeNode.matmul = False
+    if 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:
             new_children.append(simplify(child))
+        TreeNode.matmul = orig
         return TreeNode(eq.name, new_children)
     if eq.name[2:] in "gt ge lt le eq".split(" "):
         denom = eq.name != "f_eq"
         tmp2 = simplify(eq.children[0] - eq.children[1])
         tmp, denom = clear_div(tmp2, denom)
         tmp = simplify(tmp)
+        
         value2 = eq.name[2:]
         if denom is False:
             value2 = {"ge":"le", "le":"ge", "gt":"lt", "lt":"gt", "eq":"eq"}[value2]
         value2 = "f_"+value2
-        return TreeNode(value2, [tmp, tree_form("d_0")])
+        out = TreeNode(value2, [tmp, tree_form("d_0")])
+        TreeNode.matmul = orig
+        return out
     eq = flatten_tree(eq)
     if basic:
         eq = convert_to_basic(eq)
     eq = solve3(eq)
+    TreeNode.matmul = orig
     return eq

{mathai-0.6.7 → mathai-0.6.9}/mathai.egg-info/PKG-INFO

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

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

mathai-0.6.7/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)