mathai 0.7.8__tar.gz → 0.7.9__tar.gz

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

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

mathai-0.7.9/mathai/fraction.py

@@ -0,0 +1,106 @@
+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 = []
+                for f in c.children:
+                    if (
+                        f.name == "f_pow"
+                        and f.children[1].name.startswith("d_")
+                        and int(f.children[1].name[2:]) < 0
+                    ):
+                        n = int(f.children[1].name[2:])
+                        den.append(
+                            f.children[0]
+                            if n == -1
+                            else TreeNode("f_pow", [f.children[0], tree_form(f"d_{-n}")])
+                        )
+                    else:
+                        num.append(f)
+                terms.append((num, den))
+
+            # pure reciprocal
+            elif (
+                c.name == "f_pow"
+                and c.children[1].name.startswith("d_")
+                and int(c.children[1].name[2:]) < 0
+            ):
+                n = int(c.children[1].name[2:])
+                terms.append(([], [
+                    c.children[0]
+                    if n == -1
+                    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)
+            for j, (_, den_j) in enumerate(terms):
+                if i != j:
+                    acc += den_j
+            if not acc:
+                acc = [tree_form("d_1")]
+            num_terms.append(
+                acc[0] if len(acc) == 1 else TreeNode("f_mul", acc)
+            )
+
+        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",
+                [simplify(expand(numerator)), denom],
+            )
+        )
+
+    # -----------------------------
+    # default reconstruction
+    # -----------------------------
+    return TreeNode(expr.name, children)

{mathai-0.7.8 → mathai-0.7.9}/mathai/integrate.py

@@ -97,6 +97,8 @@ def place_try2(eq):
         return eq.children[try_lst.pop(0)]
     return TreeNode(eq.name, [place_try2(child) for child in eq.children]) 
 def _solve_integrate(eq):
+    if eq is None:
+        return None
     if eq.name == "f_ref":
         return eq
     if eq.name == "f_subs":
@@ -153,6 +155,8 @@ def inteq(eq):
     else:
         return TreeNode(eq.name, [inteq(child) for child in eq.children])
 def rm(eq):
+    if eq is None:
+        return None
     if eq.name == "f_try":
         eq = TreeNode(eq.name, list(set(eq.children)))
     return TreeNode(eq.name, [rm(child) for child in eq.children if child is not None])
@@ -161,6 +165,8 @@ def solve_integrate(eq):
     eq2 = dowhile(eq, _solve_integrate)
     #eq2 = dowhile(eq2, handle_try)
     eq2 = rm(eq2)
+    if eq2 is None:
+        return None
     if eq2.name == "f_try":
         eq2.children = list(set(eq2.children))
     return eq2
@@ -409,8 +415,8 @@ def integration_formula_ex():
 
 formula_gen11 = integration_formula_ex()
 def rm_const(equation):
-    if equation.name == "f_ref":
-        return equation
+    if equation is None:
+        return None
     eq2 = equation
     if eq2.name == "f_integrate" and contain(eq2.children[0], eq2.children[1]):
         equation = eq2.children[0]
@@ -436,8 +442,8 @@ def shorten(eq):
         return tree_form("d_0")
     return TreeNode(eq.name, [shorten(child) for child in eq.children])
 def integrate_formula(equation):
-    if equation.name == "f_ref":
-        return equation.copy_tree()
+    if equation is None:
+        return None
     eq2 = equation.copy_tree()
     if eq2.name == "f_integrate":
         integrand = eq2.children[0]

{mathai-0.7.8 → mathai-0.7.9}/mathai/ode.py

@@ -1,6 +1,7 @@
+import itertools
 from collections import Counter
-from .diff import diff
-from .factor import factor, factor2
+from .diff import diff, diff2
+from .factor import factor, factor2, term_common2
 from .expand import expand
 from .base import *
 from .fraction import fraction
@@ -9,71 +10,110 @@ import copy
 from .inverse import inverse
 from .parser import parse
 
-
-def jjj(lhs, rhs):
-    lst = [lhs, rhs]
-    for i in range(2):
-        if lst[i].name in ["f_mul", "f_add"]:
-            
-            out = []
-            for child in lst[i].children:
-                
-                if not contain(child, tree_form(f"v_{i}")):
-                    out.append(child)
-            if out == []:
-                continue
-            out = TreeNode(lst[i].name, out)
-            
-            if len(out.children) == 1:
-                out = out.children[0]
-            out = out.copy_tree()
-            if lst[i].name == "f_add":
-                lst[i] = lst[i] - out
-                lst[1-i] = lst[1-i] - out
-            else:
-                lst[i] = lst[i] / out
-                lst[1-i] = lst[1-i] / out
-                
-            lst = [simplify(expand(simplify(item))) for item in lst]
-    return lst
-
-def kkk(lhs, rhs, depth=3):
-    
-    lst = jjj(lhs, rhs)
-    
-    if depth < 0:
-        return lst, False
+def rev(eq):
+    tmp = factor_generation(eq)
+    if tree_form("v_0").fx("dif")**-1 in tmp or tree_form("v_1").fx("dif")**-1 in  tmp:
+        return False
+    for child in eq.children:
+        if not rev(child):
+            return False
+    return True
+node_count = 100
+def kkk(lhs, rhs, depth=5):
+    global node_count
+    lst = [simplify(lhs), simplify(rhs)]
+    orig = copy.deepcopy(lst)
     if not contain(lst[0], tree_form("v_1")) and not contain(lst[1], tree_form("v_0")):
+        if not contain(lst[0], tree_form("v_0")) and not contain(lst[1], tree_form("v_1")):
+            return lst, False
         return lst, True
-    orig = copy.deepcopy(lst)
-    for i in range(2):
-        if lst[i].name in ["f_mul", "f_add"]:
-            for child in lst[i].children:
-                
-                out = child
-                if lst[i].name == "f_add":
-                    lst[i] = lst[i] - out
-                    lst[1-i] = lst[1-i] - out
-                else:
-                    lst[i] = lst[i] / out
-                    lst[1-i] = lst[1-i] / out
-                lst = [simplify(item) for item in lst]
+    node_count -= 1
+    
+    if depth < 0 or node_count < 0:
+        return lst, False
+    for j in range(2):
+        for i in range(2):
+            if lst[i].name in ["f_mul", "f_add"]:
+                for child in lst[i].children:
+                    out = child
+                    if j == 0:
+                        if contain(out, tree_form(f"v_{i}")) or not contain(out, tree_form(f"v_{1-i}")):
+                            continue
+                    if contain(out, tree_form(f"v_{i}")) and not contain(out, tree_form(f"v_{1-i}")):
+                        continue
+                    
+                    if lst[i].name == "f_add":
+                        lst[i] = lst[i] - out
+                        lst[1-i] = lst[1-i] - out
+                    elif lst[i].name == "f_mul":
+                        lst[i] = lst[i] / out
+                        lst[1-i] = lst[1-i] / out
+                    else:
+                        continue
+                    
+                    output = kkk(lst[0], lst[1], depth-1)
+                    lst = orig
+                    
+                    if output[1]:
+                        return output
                 
-                output = kkk(lst[0], lst[1], depth-1)
-                lst = orig
-                if output[1]:
-                    return output
     return lst, False
-
+def clr(eq):
+    return simplify(product([item for item in factor_generation(eq) if "f_add" in str_form(item)]))
 def inversediff(lhs, rhs):
-    out = [[tree_form("d_0"), lhs-rhs], False]
-    while True:
-        out = list(kkk(out[0][0], out[0][1]))
-        if out[1]:
-            break
-        out[0] = [simplify(item) for item in out[0]]
+    global node_count
+    eq = simplify(fraction(TreeNode("f_eq", [lhs-rhs, tree_form("d_0")]))).children[0]
+    eq = simplify(term_common2(eq))
+    eq = clr(eq)
+    
+    out= None
+    if eq.name == "f_add":
+        h = {}
+        n = [eq]
+        for i in range(len(eq.children)-2,1,-1):
+            for item in itertools.combinations(list(range(len(eq.children))), i):
+                item = tuple(sorted(list(item)))
+                tmp = simplify(term_common2(simplify(summation([eq.children[x] for x in item]))))
+                if tmp.name == "f_mul":
+                    h[item] = tmp
+                    
+        for item in itertools.combinations(list(h.keys()),2):
+            
+            g = []
+            for x in item:
+                g += x
+            if sum([len(x) for x in item]) == len(set(g)):
+                pass
+            else:
+                continue
+            
+            item2 = summation([eq.children[x] for x in list(set(range(len(eq.children)))-set(g))])
+            n.append(simplify(term_common2(simplify(h[item[0]] + h[item[1]]))+item2))
+                
+        
+        for item in list(set(n)):
+            
+            item = clr(item)
+            node_count = 100
+            
+            tmp = kkk(item, tree_form("d_0"))
+            
+            if tmp[1]:
+                out = tmp[0]
+                break
+    else:
+        node_count = 100
+        tmp = kkk(eq, tree_form("d_0"))
+        if tmp[1]:
+            out = tmp[0]
+    if out is None:
+        return None
+    out = [simplify(fraction(item)) for item in out]
+    
+    if not rev(out[0]) and not rev(out[1]):
         
-    out = out[0]
+        out[0] = fraction(1/out[0])
+        out[1] = fraction(1/out[1])
     return simplify(e0(out[0]-out[1]))
 
 def allocvar():
@@ -88,38 +128,28 @@ def esolve(s):
         return product([tree_form("s_e")**child for child in s.children]) - tree_form("d_1")
     return TreeNode(s.name, [esolve(child) for child in s.children])
 def diffsolve_sep2(eq):
-    global tab
-    
-    s = []
-    eq = simplify(expand(eq))
-    eq = e1(eq)
-    
-    def vlor1(eq):
-        if contain(eq, tree_form("v_0")) and not contain(eq, tree_form("v_1")):
-            return True
-        if contain(eq, tree_form("v_1")) and not contain(eq, tree_form("v_0")):
-            return True
-        return False
-    if eq.name == "f_add" and all(vlor1(child) and [str_form(x) for x in factor_generation(copy.deepcopy(child))].count(str_form(tree_form(vlist(child)[0]).fx("dif")))==1 for child in eq.children):
-        for child in eq.children:
-            v = vlist(child)[0]
-            v2 = tree_form(v).fx("dif")
-            child = replace(child, v2, tree_form("d_1"))
-            child = simplify(child)
-            
-            
-            tmp6 = TreeNode("f_integrate", [child, tree_form(v)])
-            s.append(tmp6)
-            
-            if s[-1] is None:
-                return None
-        s.append(allocvar())
-    else:
+    lst = None
+    if eq is None:
         return None
-    s = summation(s)
-    s = simplify(e0(s))
+    eq = eq.children[0]
+    if eq.name == "f_add":
+        lst = list(eq.children)
+    else:
+        lst = [eq]
+    s = [allocvar()]
+    
+    for item in lst:
+        item = simplify(item)
+        tmp = factor_generation(item)
+        
+        tmp2 = product([k for k in tmp if k.name != "f_dif"])
+        
+        if tree_form("v_0").fx("dif") in tmp:
+            s.append(TreeNode("f_integrate", [tmp2, tree_form("v_0")]))
+        elif tree_form("v_1").fx("dif") in tmp:
+            s.append(TreeNode("f_integrate", [tmp2, tree_form("v_1")]))
     
-    return groupe(s)
+    return TreeNode("f_eq", [summation(s), tree_form("d_0")])
 def e0(eq):
     return TreeNode("f_eq", [eq, tree_form("d_0")])
 def e1(eq):
@@ -136,11 +166,17 @@ def groupe(eq):
 
 def diffsolve_sep(eq):
     eq = epowersplit(eq)
+    
     eq = inversediff(tree_form("d_0"), eq.children[0].copy_tree())
+    
     return eq
 
 def diffsolve(eq):
     orig = eq.copy_tree()
+    eq = diff2(eq)
+    eq = subs2(eq, order(eq))
+    eq = fraction(simplify(fraction(eq)))
+    
     if order(eq) == 2:
         for i in range(2):
             out = second_order_dif(eq, tree_form(f"v_{i}"), tree_form(f"v_{1-i}"))
@@ -149,28 +185,38 @@ def diffsolve(eq):
         return orig
     
     eq = diffsolve_sep2(diffsolve_sep(eq))
+    
     if eq is None:
         for i in range(2):
             a = tree_form(f"v_{i}")
             b = tree_form(f"v_{1-i}")
             c = tree_form("v_2")
-            eq2 = replace(orig, b,b*a)
-            eq2 = replace(eq2, (a*b).fx("dif"), a.fx("dif")*b + b.fx("dif")*a)
-            eq2 = expand(simplify(fraction(simplify(eq2))))
+            eq2 = orig
+            
+            eq2 = subs2(eq2, 1)
+            eq2 = replace(eq2, b, b*a)
+            eq2 = subs3(eq2)
+            
+            eq2 = simplify(fraction(simplify(eq2)))
+            
             eq2 = diffsolve_sep(eq2)
+            
             eq2 = diffsolve_sep2(eq2)
             if eq2 is not None:
                 return e0(TreeNode("f_subs", [replace(eq2.children[0],b,c), c,b/a]).fx("try"))
         eq = orig
-    
-    eq = fraction(eq)
-    eq = simplify(eq)
-    for i in range(2):
-        
-        out = linear_dif(eq, tree_form(f"v_{i}"), tree_form(f"v_{1-i}"))
-        if out is not None:
-            return out
-    return eq
+        eq = simplify(eq)
+        eq = subs2(eq, 1)
+        eq = fraction(eq)
+        for i in range(2):
+            
+            out = linear_dif(eq, tree_form(f"v_{i}"), tree_form(f"v_{1-i}"))
+            if out is not None:
+                return out
+        return orig
+    else:
+        return eq
+
 def clist(x):
     return list(x.elements())
 def collect_term(eq, term_lst):
@@ -219,6 +265,19 @@ def order(eq,m=0):
             out = order(child, m)
             best = max(out, best)
     return best
+def subs2(eq, orde):
+    if eq.name in ["f_dif", "f_pdif"] and len(eq.children) == 2:
+        if orde == 1:
+            return eq.children[0].fx("dif")/eq.children[1].fx("dif")
+        else:
+            return subs2(TreeNode("f_dif", eq.children), orde)
+    return TreeNode(eq.name, [subs2(child, orde) for child in eq.children])
+def subs3(eq):
+    if eq.name == "f_dif" and eq.children[0].name == "f_add":
+        return summation([subs3(child.fx("dif")) for child in eq.children[0].children])
+    if eq.name == "f_dif" and eq.children[0].name == "f_mul":
+        return summation([product([subs3(child.fx("dif")) if index==index2 else child for index2, child in enumerate(eq.children[0].children)]) for index in range(len(eq.children[0].children))])
+    return TreeNode(eq.name, [subs3(child) for child in eq.children])
 def second_order_dif(eq, a, b):
     eq = simplify(eq)
     nn = [TreeNode("f_dif", [TreeNode("f_dif", [b,a]),a]), TreeNode("f_dif", [b,a]), b]
@@ -260,7 +319,8 @@ def linear_dif(eq, a, b):
             for key in out[0].keys():
                 out[0][key] = simplify(out[0][key]/tmp)
             p, q = out[0][b*a.fx("dif")], -out[0][a.fx("dif")]
-            
+            if contain(p, b) or contain(q, b):
+                return None
             f = tree_form("s_e") ** TreeNode("f_integrate", [p, a])
             return simplify(TreeNode("f_eq", [b*f, TreeNode("f_integrate", [q*f, a])+allocvar()]))
     return None

{mathai-0.7.8 → mathai-0.7.9}/mathai/pde.py

@@ -1,5 +1,5 @@
 from .expand import expand
-from .ode import diffsolve, inversediff, order, groupe, epowersplit
+from .ode import diffsolve, inversediff, order, groupe, epowersplit, subs2
 from .base import *
 from .simplify import simplify
 from .diff import diff2
@@ -16,13 +16,7 @@ def capital2(eq):
         if out is not None:
             return out
     return None
-def subs2(eq, orde):
-    if eq.name == "f_pdif":
-        if orde == 1:
-            return eq.children[0].fx("dif")/eq.children[1].fx("dif")
-        else:
-            return subs2(TreeNode("f_dif", eq.children), orde)
-    return TreeNode(eq.name, [subs2(child, orde) for child in eq.children])
+
 def capital(eq):
     if eq.name[:2] == "f_" and eq.name != eq.name.lower():
         return eq
@@ -36,6 +30,8 @@ def abs_const(eq):
         return tree_form("v_101")*eq.children[0]
     return TreeNode(eq.name, [abs_const(child) for child in eq.children])
 def want(eq):
+    if eq is None:
+        return None
     if eq.name == "f_want":
         
         eq2 = eq.children[0]
@@ -95,8 +91,7 @@ def pde_sep(eq):
             r = capital(out[i])
             lst.append(r)
             out[i] = replace(out[i], r, tree_form(f"v_{1-i}"))
-            out[i] = subs2(out[i], order(out[i]))
-            
+            out[i] = tree_form(str_form(out[i]).replace("f_pdif", "f_dif"))
             out[i] = diffsolve(out[i])
             
             out[i] = replace(out[i], tree_form(f"v_{1-i}"), r)

{mathai-0.7.8 → mathai-0.7.9}/mathai/structure.py

@@ -2,7 +2,7 @@ import itertools
 from .simplify import simplify
 from .base import *
 
-def structure(equation, formula, formula_out=None, only_const=False):
+def structure(equation, formula, formula_out=None, only_const=False, wrt=None):
     varlist = {}
     def helper(equation, formula):
         nonlocal varlist
@@ -60,7 +60,7 @@ def structure(equation, formula, formula_out=None, only_const=False):
     for item in lst(formula):
         varlist = {}
         if helper(equation, item):
-            if only_const and any("v_" in str_form(varlist[key]) for key in varlist.keys()):
+            if only_const and any(contain(varlist[key], tree_form(wrt)) for key in varlist.keys()):
                 continue
             if formula_out is None:
                 return varlist
@@ -90,7 +90,7 @@ def transform_formula(equation, wrt, formula_list, var, expr):
             if var != "":
                 p = True
             try:
-                out = structure(equation.copy_tree(), copy.deepcopy(item[0]), copy.deepcopy(item[1]), p)
+                out = structure(equation.copy_tree(), copy.deepcopy(item[0]), copy.deepcopy(item[1]), p, wrt)
                 if out is not None:
                     out = simplify(out)
                     

{mathai-0.7.8 → mathai-0.7.9}/mathai.egg-info/PKG-INFO

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

{mathai-0.7.8 → mathai-0.7.9}/setup.py

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

mathai-0.7.8/mathai/fraction.py

@@ -1,103 +0,0 @@
-from .base import *
-from .simplify import simplify
-from .expand import expand
-
-def fraction(eq):
-    stack = [(eq, None)]  # (current_node, parent_processed_children)
-    result_map = {}  # Map original nodes to their processed TreeNode
-
-    while stack:
-        node, parent_info = stack.pop()
-
-        # If node already processed, continue
-        if node in result_map:
-            continue
-
-        # Base case: leaf node
-        if not node.children:
-            result_map[node] = TreeNode(node.name, [])
-            continue
-
-        # Check if all children are processed
-        all_children_done = all(child in result_map for child in node.children)
-        if not all_children_done:
-            # Push current node back to stack after children
-            stack.append((node, parent_info))
-            for child in reversed(node.children):
-                if child not in result_map:
-                    stack.append((child, (node, node.children)))
-            continue
-
-        # Now all children are processed, handle this node
-        if node.name == "f_eq":
-            left = result_map[node.children[0]]
-            right = result_map[node.children[1]]
-            result_map[node] = TreeNode("f_eq", [left, right])
-            continue
-
-        elif node.name == "f_add":
-            con = []
-            for child in node.children:
-                child_processed = result_map[child]
-                if child_processed.name == "f_pow" and child_processed.children[1].name[:2] == "d_" and int(child_processed.children[1].name[2:]) < 0:
-                    den = []
-                    n = int(child_processed.children[1].name[2:])
-                    if n == -1:
-                        den.append(child_processed.children[0])
-                    else:
-                        den.append(TreeNode("f_pow", [child_processed.children[0], tree_form("d_" + str(-n))]))
-                    con.append([[], den])
-                elif child_processed.name == "f_mul":
-                    num = []
-                    den = []
-                    for child2 in child_processed.children:
-                        if child2.name == "f_pow" and child2.children[1].name[:2] == "d_" and int(child2.children[1].name[2:]) < 0:
-                            n = int(child2.children[1].name[2:])
-                            if n == -1:
-                                den.append(child2.children[0])
-                            else:
-                                den.append(TreeNode("f_pow", [child2.children[0], tree_form("d_" + str(-n))]))
-                        else:
-                            num.append(child2)
-                    con.append([num, den])
-                else:
-                    con.append([[child_processed], []])
-
-            if len(con) > 1 and any(x[1] != [] for x in con):
-                # Construct numerator
-                a_children = []
-                for i in range(len(con)):
-                    b_children = con[i][0].copy()
-                    for j in range(len(con)):
-                        if i == j:
-                            continue
-                        b_children += con[j][1]
-                    if len(b_children) == 0:
-                        b_children = [tree_form("d_1")]
-                    elif len(b_children) == 1:
-                        b_children = b_children
-                    else:
-                        b_children = [TreeNode("f_mul", b_children)]
-                    a_children += b_children if isinstance(b_children, list) else [b_children]
-
-                a = TreeNode("f_add", a_children)
-
-                # Construct denominator
-                c_children = []
-                for i in range(len(con)):
-                    c_children += con[i][1]
-                if len(c_children) == 1:
-                    c = c_children[0]
-                else:
-                    c = TreeNode("f_mul", c_children)
-                c = TreeNode("f_pow", [c, tree_form("d_-1")])
-
-                result_map[node] = TreeNode("f_mul", [simplify(expand(simplify(a))), c])
-                continue
-
-        # Default: just reconstruct node
-        children_processed = [result_map[child] for child in node.children]
-        result_map[node] = TreeNode(node.name, children_processed)
-
-    # Final return
-    return simplify(result_map[eq])