mathai 0.7.9__tar.gz → 0.8.1__tar.gz

{mathai-0.7.9 → mathai-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.7.9
+Version: 0.8.1
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai4
 Requires-Python: >=3.7

{mathai-0.7.9 → mathai-0.8.1}/mathai/apart.py

@@ -107,13 +107,14 @@ def _apart(eq, v=None):
     
     lst = poly(s.children[0], v)
     
-    lst = [TreeNode("f_eq", [item, tree_form("d_0")]) for item in lst if "v_" in str_form(item)]
+    lst = [simplify(TreeNode("f_eq", [item, tree_form("d_0")])) for item in lst if "v_" in str_form(item)]
     lst2 = []
     for item in lst:
         lst2+=vlist(item)
     origv = list(set(lst2)-set(origv))
     
     out = linear_solve(TreeNode("f_and", lst), [tree_form(item) for item in origv])
+
     for item in out.children:
         
         final3 = replace(final3, tree_form(list(set(vlist(item))&set(origv))[0]), inverse(item.children[0], list(set(vlist(item))&set(origv))[0]))
@@ -139,4 +140,6 @@ def apart(eq):
             return eq2
        
         return TreeNode(eq.name, [helper(child) for child in eq.children])
-    return fx(helper(eq))
+    eq = helper(eq)
+    eq = fx(eq)
+    return eq

{mathai-0.7.9 → mathai-0.8.1}/mathai/base.py

@@ -334,7 +334,7 @@ def vlist(eq):
         out.append(eq.name)
     for child in eq.children:
         out += vlist(child)
-    return sorted(list(set(out)), key=lambda x: int(x[2:]))
+    return list(sorted(list(set(out)), key=lambda x: int(x[2:])))
 def product(lst):
     if lst == []:
         return tree_form("d_1")

{mathai-0.7.9 → mathai-0.8.1}/mathai/expand.py

@@ -3,21 +3,12 @@ from .simplify import simplify
 import itertools
 
 def expand_nc(expr, label="f_mul"):
-    """
-    Expand expression where:
-      - f_add is commutative
-      - label (@) is NON-commutative
-    """
-    # --- base cases ---
+
     if expr.name not in {"f_add", label, "f_pow"}:
         return expr
 
-    # --- expand children first ---
     expr.children = [expand_nc(c, label) for c in expr.children]
 
-    # ==========================================================
-    # POWER: (A + B)^n  only if n is positive integer
-    # ==========================================================
     if expr.name == "f_pow":
         base, exp = expr.children
         n = frac(exp)
@@ -26,9 +17,6 @@ def expand_nc(expr, label="f_mul"):
             return expand_nc(TreeNode(label, factors), label)
         return expr
 
-    # ==========================================================
-    # ADDITION (commutative)
-    # ==========================================================
     if expr.name == "f_add":
         out = []
         for c in expr.children:
@@ -38,20 +26,15 @@ def expand_nc(expr, label="f_mul"):
                 out.append(c)
         return TreeNode("f_add", out)
 
-    # ==========================================================
-    # NON-COMMUTATIVE MULTIPLICATION (@)
-    # ==========================================================
     if expr.name == label:
         factors = []
 
-        # flatten only (NO reordering)
         for c in expr.children:
             if c.name == label:
                 factors.extend(c.children)
             else:
                 factors.append(c)
 
-        # find first additive factor
         for i, f in enumerate(factors):
             if f.name == "f_add":
                 left  = factors[:i]
@@ -66,13 +49,12 @@ def expand_nc(expr, label="f_mul"):
 
                 return TreeNode("f_add", terms)
 
-        # no addition inside → return as-is
         return TreeNode(label, factors)
 
-
 def expand2(eq, over="*"):
     over = {"@": "f_wmul", ".":"f_dot", "*":"f_mul"}[over]
     return expand_nc(eq, over)
 def expand(eq, over="*"):
     eq = expand2(eq, over)
     return TreeNode(eq.name, [expand(child, over) for child in eq.children])
+

{mathai-0.7.9 → mathai-0.8.1}/mathai/fraction.py

@@ -2,30 +2,22 @@ from .base import *
 from .simplify import simplify
 from .expand import expand
 
-
 def fraction(expr):
     if expr is None:
         return None
-    
+
     expr = simplify(expr)
-    
-    # -----------------------------
-    # leaf
-    # -----------------------------
+
     if expr.children == []:
         return expr
 
-    # recurse first (inner-most first)
     children = [fraction(c) for c in expr.children]
 
-    # -----------------------------
-    # ADDITION: collect denominators
-    # -----------------------------
     if expr.name == "f_add":
         terms = []
 
         for c in children:
-            # term is a multiplication
+
             if c.name == "f_mul":
                 num = []
                 den = []
@@ -45,7 +37,6 @@ def fraction(expr):
                         num.append(f)
                 terms.append((num, den))
 
-            # pure reciprocal
             elif (
                 c.name == "f_pow"
                 and c.children[1].name.startswith("d_")
@@ -58,17 +49,12 @@ def fraction(expr):
                     else TreeNode("f_pow", [c.children[0], tree_form(f"d_{-n}")])
                 ]))
 
-            # normal term
             else:
                 terms.append(([c], []))
 
-        # if no denominators → rebuild normally
         if not any(den for _, den in terms):
             return TreeNode("f_add", children)
 
-        # -----------------------------
-        # build numerator
-        # -----------------------------
         num_terms = []
         for i, (num_i, _) in enumerate(terms):
             acc = list(num_i)
@@ -83,16 +69,13 @@ def fraction(expr):
 
         numerator = TreeNode("f_add", num_terms)
 
-        # -----------------------------
-        # build denominator
-        # -----------------------------
         den_all = []
         for _, den in terms:
             den_all += den
 
         denom = den_all[0] if len(den_all) == 1 else TreeNode("f_mul", den_all)
         denom = TreeNode("f_pow", [denom, tree_form("d_-1")])
-        
+
         return simplify(
             TreeNode(
                 "f_mul",
@@ -100,7 +83,5 @@ def fraction(expr):
             )
         )
 
-    # -----------------------------
-    # default reconstruction
-    # -----------------------------
     return TreeNode(expr.name, children)
+

{mathai-0.7.9 → mathai-0.8.1}/mathai/linear.py

@@ -8,7 +8,7 @@ from .base import *
 from .factor import factorconst
 from .tool import poly
 def ss(eq):
-    return dowhile(eq, lambda x: fraction(expand(simplify(x))))
+    return dowhile(eq, lambda x: fraction(simplify(x)))
 def rref(matrix):
     rows, cols = len(matrix), len(matrix[0])
     lead = 0
@@ -34,16 +34,17 @@ def rref(matrix):
     return matrix
 def islinear(eq, fxconst):
     eq =simplify(eq)
-    if all(fxconst(tree_form(item)) and poly(eq, item) is not None and len(poly(eq, item)) <= 2 for item in vlist(eq)):
+    if all(not fxconst(tree_form(item)) or (fxconst(tree_form(item)) and poly(eq, item) is not None and len(poly(eq, item)) <= 2)for item in vlist(eq)):
         return True
+    else:
+        pass
     return False
 def linear(eqlist, fxconst):
     orig = [item.copy_tree() for item in eqlist]
-    #eqlist = [eq for eq in eqlist if fxconst(eq)]
     
     if eqlist == [] or not all(islinear(eq, fxconst) for eq in eqlist):
         return None
-        #return TreeNode("f_and", [TreeNode("f_eq", [x, tree_form("d_0")]) for x in orig])
+
     vl = []
     def varlist(eq, fxconst):
         nonlocal vl
@@ -58,6 +59,7 @@ def linear(eqlist, fxconst):
     if len(vl) > len(eqlist):
         return TreeNode("f_and", [TreeNode("f_eq", [x, tree_form("d_0")]) for x in eqlist])
     m = []
+    
     for eq in eqlist:
         s = copy.deepcopy(eq)
         row = []
@@ -71,11 +73,11 @@ def linear(eqlist, fxconst):
             m[i][j] = simplify(expand(m[i][j]))
 
     m = rref(m)
-    
+
     for i in range(len(m)):
         for j in range(len(m[i])):
             m[i][j] = fraction(m[i][j])
-    
+
     output = []
     for index, row in enumerate(m):
         if not all(item == 0 for item in row[:-1]):
@@ -88,26 +90,17 @@ def linear(eqlist, fxconst):
         return tree_form("s_false")
     return TreeNode("f_and", [TreeNode("f_eq", [x, tree_form("d_0")]) for x in output])
 def order_collinear_indices(points, idx):
-    """
-    Arrange a subset of collinear points (given by indices) along their line.
     
-    points: list of (x, y) tuples
-    idx: list of indices referring to points
-    Returns: list of indices sorted along the line
-    """
     if len(idx) <= 1:
         return idx[:]
-    
-    # Take first two points from the subset to define the line
+
     p0, p1 = points[idx[0]], points[idx[1]]
     dx, dy = p1[0] - p0[0], p1[1] - p0[1]
-    
-    # Projection factor for sorting
+
     def projection_factor(i):
         vx, vy = points[i][0] - p0[0], points[i][1] - p0[1]
         return compute((vx * dx + vy * dy) / (dx**2 + dy**2))
-    
-    # Sort indices by projection
+
     sorted_idx = sorted(idx, key=projection_factor)
     return list(sorted_idx)
 def linear_or(eq):
@@ -124,12 +117,12 @@ def linear_or(eq):
     for item in itertools.combinations(enumerate(eqlst), 2):
         x, y = item[0][0],  item[1][0]
         item = [item[0][1], item[1][1]]
-        
+
         out = linear_solve(TreeNode("f_and", list(item)))
 
         if out is None:
             return None
-        
+
         if out.name == "f_and" and all(len(vlist(child)) == 1 for child in out.children) and set(vlist(out)) == set(v) and all(len(vlist(simplify(child))) >0 for child in out.children):
             t = {}
             for child in out.children:
@@ -151,7 +144,7 @@ def linear_solve(eq, lst=None):
     eq = simplify(eq)
     eqlist = []
     if eq.name =="f_and" and all(child.name == "f_eq" and child.children[1] == 0 for child in eq.children):
-        
+
         eqlist = [child.children[0] for child in eq.children]
     else:
         return eq
@@ -159,7 +152,9 @@ def linear_solve(eq, lst=None):
     if lst is None:
         out = linear(copy.deepcopy(eqlist), lambda x: "v_" in str_form(x))
     else:
+        
         out = linear(copy.deepcopy(eqlist), lambda x: any(contain(x, item) for item in lst))
     if out is None:
         return None
     return simplify(out)
+

{mathai-0.7.9 → mathai-0.8.1}/mathai/logic.py

@@ -108,7 +108,7 @@ def logic2(eq):
             if len(lst) == 1:
                 return lst[0]
             return TreeNode(eq.name, lst)
-    
+
     if eq.name in ["f_and", "f_or"] and any(child.children is not None and len(child.children)!=0 for child in eq.children):
         for i in range(len(eq.children),1,-1):
             for item in itertools.combinations(enumerate(eq.children), i):
@@ -159,7 +159,7 @@ def logic1(eq):
             A, B = dowhile(A, logic2), dowhile(B, logic2)
             return flatten_tree((A & B) | (A.fx("not") & B.fx("not")))
         if eq.name == "f_imply":
-            
+
             A, B = eq.children
             A, B = logic1(A), logic1(B)
             A, B = dowhile(A, logic2), dowhile(B, logic2)
@@ -171,32 +171,28 @@ def logic1(eq):
         return eq
     eq = helper(eq)
     eq = flatten_tree(eq)
-    
+
     if len(eq.children) > 2:
         lst = []
         l = len(eq.children)
 
-        # Handle last odd child directly
         if l % 2 == 1:
             last_child = eq.children[-1]
-            # expand/simplify only if needed
+
             if isinstance(last_child, TreeNode):
                 last_child = dowhile(last_child, logic2)
             lst.append(last_child)
             l -= 1
 
-        # Pairwise combine children
         for i in range(0, l, 2):
             left, right = eq.children[i], eq.children[i+1]
             pair = TreeNode(eq.name, [left, right])
             simplified = dowhile(logic1(pair), logic2)
             lst.append(simplified)
 
-        # If only one element left, just return it instead of nesting
         if len(lst) == 1:
             return flatten_tree(lst[0])
 
-        # Otherwise rewrap
         return flatten_tree(TreeNode(eq.name, lst))
 
     if eq.name == "f_and":
@@ -228,3 +224,4 @@ def logic1(eq):
             out = out.children[0]
         return flatten_tree(out)
     return TreeNode(eq.name, [logic1(child) for child in eq.children])
+

{mathai-0.7.9 → mathai-0.8.1}/mathai/matrix.py

@@ -3,7 +3,6 @@ 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]
@@ -14,16 +13,13 @@ def py_to_tree(obj):
         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")
@@ -33,9 +29,7 @@ def dot(u,v):
     return s
 
 def matmul(A, B):
-    # A: n × m
-    # B: m × p
-    
+
     n = len(A)
     m = len(A[0])
     p = len(B[0])
@@ -54,7 +48,6 @@ def matmul(A, B):
                 )
     return C
 
-# ---------- promotion ----------
 def promote(node):
     if node.name=="f_list":
         return tree_to_py(node)
@@ -68,7 +61,7 @@ def contains_neg(node):
         if not contains_neg(child):
             return False
     return True
-# ---------- multiplication (fully simplified) ----------
+
 def multiply(left,right):
     if left == tree_form("d_1"):
         return right
@@ -83,17 +76,16 @@ def multiply(left,right):
         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
@@ -122,45 +114,16 @@ def matadd(A, B):
     ]
 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 = {}
 
@@ -168,17 +131,15 @@ def fold_wmul(root):
         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:
@@ -208,8 +169,6 @@ def fold_wmul(root):
                             eq.children.insert(i - 1, out)
                         i -= 1
 
-            # --------------------------------
-
             newnode[node] = eq
 
     return newnode[root]
@@ -223,3 +182,4 @@ def _matrix_solve(eq):
     return eq
 def matrix_solve(eq):
     return _matrix_solve(eq)
+

{mathai-0.7.9 → mathai-0.8.1}/mathai/parser.py

@@ -87,7 +87,6 @@ def parse(equation, funclist=None):
     parser_main = Lark(grammar2, start='start', parser='lalr')
     parse_tree = parser_main.parse(equation)
     
-    # Convert Lark tree to TreeNode
     def convert_to_treenode(parse_tree):
         if isinstance(parse_tree, Tree):
             node = TreeNode(parse_tree.data)
@@ -96,7 +95,6 @@ def parse(equation, funclist=None):
         else:
             return TreeNode(str(parse_tree))
 
-    # Flatten unnecessary nodes like pass_through
     def remove_past(equation):
         if equation.name in {"number", "paren", "func", "variable", "pass_through", "cnumber", "string", "matrix"}:
             if len(equation.children) == 1:
@@ -107,7 +105,6 @@ def parse(equation, funclist=None):
         equation.children = [remove_past(child) for child in equation.children]
         return equation
 
-    # Handle indices if any
     def prefixindex(equation):
         if equation.name == "base" and len(equation.children) > 1:
             return TreeNode("index", [equation.children[0]] + equation.children[1].children)
@@ -117,16 +114,15 @@ def parse(equation, funclist=None):
     tree_node = remove_past(tree_node)
     tree_node = prefixindex(tree_node)
 
-    # Convert function names and constants
     def fxchange(tree_node):
         tmp3 = funclist if funclist is not None else []
         if tree_node.name == "neg":
             child = fxchange(tree_node.children[0])
-            # if the child is a number, make it negative
+            
             if child.name.startswith("d_") and re.match(r"d_\d+(\.\d+)?$", child.name):
                 return TreeNode("d_" + str(-int(child.name[2:])))
             else:
-                # otherwise subtract from zero
+
                 return TreeNode("f_sub", [tree_form("d_0"), child])
         if tree_node.name == "pass_through":
             return fxchange(tree_node.children[0])
@@ -137,11 +133,9 @@ def parse(equation, funclist=None):
 
     tree_node = fxchange(tree_node)
 
-    # Replace common constants
     for const in ["e","pi","kc","em","ec","anot","hbar","false","true","i","nabla"]:
         tree_node = replace(tree_node, tree_form("d_"+const), tree_form("s_"+const))
 
-    # Map letters to variables
     for i, c in enumerate(["x","y","z"] + [chr(x+ord("a")) for x in range(0,23)]):
         tree_node = replace(tree_node, tree_form("d_"+c), tree_form("v_"+str(i)))
     for i, c in enumerate([chr(x+ord("A")) for x in range(0,26)]):