mathai 0.6.8__tar.gz → 0.7.0__tar.gz

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

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

@@ -2,6 +2,8 @@ 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:
@@ -10,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 = []
@@ -247,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":
@@ -365,21 +370,23 @@ def product(lst):
     for item in lst[1:]:
         s *= item
     return s
-def flatten_tree(node, add=[]):
+def flatten_tree(node):
+    if node is None:
+        return None
     if not node.children:
         return node
     ad = []
     if node.name in ["f_add", "f_mul", "f_and", "f_or", "f_wmul"]:
         merged_children = []
         for child in node.children:
-            flattened_child = flatten_tree(child, add)
+            flattened_child = flatten_tree(child)
             if flattened_child.name == node.name:
                 merged_children.extend(flattened_child.children)
             else:
                 merged_children.append(flattened_child)
         return TreeNode(node.name, merged_children)
     else:
-        node.children = [flatten_tree(child, add) for child in node.children]
+        node.children = [flatten_tree(child) for child in node.children]
         return node
 def dowhile(eq, fx):
     if eq is None:

mathai-0.7.0/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.8 → mathai-0.7.0}/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.8 → mathai-0.7.0}/mathai/matrix.py

@@ -215,14 +215,13 @@ def fold_wmul(root):
     return newnode[root]
 
 def flat(eq):
-    return flatten_tree(eq, ["f_wmul"])
+    return flatten_tree(eq)
 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 = use(eq)
-        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.8 → mathai-0.7.0}/mathai/parser.py

@@ -154,7 +154,7 @@ def parse(equation, funclist=None):
         return tree_node
     
     tree_node = rfx(tree_node)
-    tree_node = flatten_tree(tree_node, ["f_wmul"])
+    tree_node = flatten_tree(tree_node)
     if TreeNode.matmul == True:
         TreeNode.matmul = False
         tree_node = use(tree_form(str_form(tree_node).replace("f_w","f_")))

{mathai-0.6.8 → mathai-0.7.0}/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.8 → mathai-0.7.0}/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
@@ -503,23 +510,28 @@ def simplify(eq, basic=True):
     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)

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

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

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

mathai-0.6.8/mathai/expand.py

@@ -1,129 +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 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)