mathai 0.4.6__tar.gz → 0.4.8__tar.gz

{mathai-0.4.6 → mathai-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.4.6
+Version: 0.4.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
@@ -16,6 +16,9 @@ Dynamic: requires-python
 Dynamic: summary
 
 # Math AI Documentation
+## Source
+Github repository of the code
+https://github.com/infinity390/mathai4
 
 ## Philosophy
 I think it is a big realization in computer science and programming to realize that computers can solve mathematics.  

{mathai-0.4.6 → mathai-0.4.8}/README.md

@@ -1,4 +1,7 @@
 # Math AI Documentation
+## Source
+Github repository of the code
+https://github.com/infinity390/mathai4
 
 ## Philosophy
 I think it is a big realization in computer science and programming to realize that computers can solve mathematics.  

{mathai-0.4.6 → mathai-0.4.8}/mathai/__init__.py

@@ -1,6 +1,8 @@
 from .ode import diffsolve as ode_solve
 from .ode import diffsolve_sep as ode_shift_term
 
+from .linear import linear_solve
+
 from .expand import expand
 
 from .parser import parse
@@ -35,7 +37,7 @@ from .trig import trig0, trig1, trig2, trig3, trig4
 
 from .logic import logic0, logic1, logic2, logic3
 
-from .apart import apart
+from .apart import apart, apart2
 
 from .console import console
 
@@ -46,4 +48,5 @@ from .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt
 from .base import *
 
 from .tool import enclose_const
-
+from .tool import poly_simplify
+from .tool import longdiv

{mathai-0.4.6 → mathai-0.4.8}/mathai/apart.py

@@ -6,19 +6,23 @@ from .diff import diff
 from .inverse import inverse
 from .base import *
 import math
-from .tool import poly, enclose_const
+from .factor import factor2
+from .tool import poly, enclose_const, longdiv
 
 def _apart(eq, v=None):
+    
     if v is None:
         if len(vlist(eq)) == 0:
             return eq
         v = vlist(eq)[0]
     origv = vlist(eq)
-    eq = simplify(eq)
+    
     if eq.name != "f_mul":
         return eq
+    
     if any("f_"+item in str_form(eq) for item in "sin cos tan log".split(" ")):
         return eq
+    
     def exclude(eq):
         if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]).denominator != 1:
             return False
@@ -48,7 +52,7 @@ def _apart(eq, v=None):
     
     
     facd2 = remove_duplicates_custom(facd, lambda m, n: simplify(expand(simplify(m-n))) == tree_form("d_0"))
-
+    
     if len(facd2) == 1:
         return eq
     x = tree_form(v)
@@ -60,7 +64,7 @@ def _apart(eq, v=None):
         g = countfac(facd, item)
         for n in range(int(g.name[2:])):
             n = n+1
-            if n > 2:
+            if n > 3:
                 return eq
             n = tree_form("d_"+str(n))
             
@@ -87,6 +91,7 @@ def _apart(eq, v=None):
                     dem.append(item**n)
                     s.append(a/item**n)
             else:
+                
                 return eq
     final3 = summation(s)
     
@@ -95,13 +100,13 @@ def _apart(eq, v=None):
     final2 = []
     for i in range(len(num)):
         final2.append(product([dem[k] for k in range(len(dem)) if i != k])*num[i])
-
+    
     final = summation(final2)
-   
+    
     s = simplify(TreeNode("f_eq", [final-eq2, tree_form("d_0")]))
-
+    
     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)]
     lst2 = []
     for item in lst:
@@ -112,12 +117,26 @@ def _apart(eq, v=None):
     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]))
-    return simplify(final3)
+    final4 = simplify(final3)
+    
+    return final4
+def apart2(eq):
+    if eq.name == "f_mul":
+        
+        a, b = num_dem(eq)
+        
+        tmp = longdiv(a, b, 2, 1)
+        
+        if tmp is not None:
+            return simplify(tmp[0]+tmp[1]/b)
+    return TreeNode(eq.name, [apart2(child) for child in eq.children])
 def apart(eq):
+    eq = factor2(simplify(eq))
     eq, fx = enclose_const(eq)
     def helper(eq):
         eq2 = _apart(eq)
         if eq != eq2:
             return eq2
+       
         return TreeNode(eq.name, [helper(child) for child in eq.children])
     return fx(helper(eq))

{mathai-0.4.6 → mathai-0.4.8}/mathai/base.py

@@ -255,7 +255,7 @@ def num_dem(equation):
     return [num, tree_form("d_1")/den]
 
 def summation(lst):
-    if lst == []:
+    if len(lst) == 0:
         return tree_form("d_0")
     s = lst[0]
     for item in lst[1:]:

{mathai-0.4.6 → mathai-0.4.8}/mathai/factor.py

@@ -5,6 +5,7 @@ from .base import *
 from .simplify import simplify,solve
 from .expand import expand
 import math
+from .tool import poly
 
 from collections import Counter
 def multiset_intersection(*lists):
@@ -42,6 +43,7 @@ def take_common(eq):
                     eq2 = term_common(eq2)
                     if eq2.name == "f_mul":
                         return take_common(solve(summation([item2 for index, item2 in enumerate(eq.children) if index not in item]) + eq2))
+                break
         return eq
     return term_common(eq)
 def take_common2(eq):
@@ -158,12 +160,6 @@ def rationalize_sqrt(eq):
     return TreeNode(eq.name, [rationalize_sqrt(child) for child in eq.children])
 def factorconst(eq):
     return simplify(_factorconst(eq))
-def factor_quad_formula_init():
-    var = ""
-    formula_list = [(f"(A*D^2+B*D+C)", f"A*(D-(-B+(B^2-4*A*C)^(1/2))/(2*A))*(D-(-B-(B^2-4*A*C)^(1/2))/(2*A))")]
-    formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
-    expr = [[parse("A"), parse("1")], [parse("B"), parse("0"), parse("1")], [parse("C"), parse("0")]]
-    return [formula_list, var, expr]
 
 def factor_quar_formula_init():
     var = ""
@@ -171,51 +167,115 @@ def factor_quar_formula_init():
     formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
     expr = [[parse("A")], [parse("B"), parse("0"), parse("1")], [parse("C"), parse("0")]]
     return [formula_list, var, expr]
-def factor_cube_formula_init():
-    var = ""
-    formula_list = [(f"D^3+E", f"(D+E^(1/3))*(D^2-D*E^(1/3)+E^(2/3))"), (f"D^3-E", f"(D-E^(1/3))*(D^2+D*E^(1/3)+E^(2/3))"),\
-                    (f"-D^3+E", f"(-D+E^(1/3))*(D^2+D*E^(1/3)+E^(2/3))")]
-    formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
-    expr = [[parse("A")], [parse("B")]]
-    return [formula_list, var, expr]
-formula_gen2 = factor_quad_formula_init()
-formula_gen3 = factor_cube_formula_init()
+
 formula_gen9 = factor_quar_formula_init()
 def factor_helper(equation, complexnum, power=2):
-    global formula_gen2, formula_gen3, formula_gen9
-    maxnum = 1
+    global formula_gen9
+    
+    maxnum=1
+    alloclst = []
+    for i in range(0,26):
+        if "v_"+str(i) not in vlist(equation):
+            alloclst.append("v_"+str(i))
+    r = alloclst.pop(0)
+    fx = None
+    curr = None
     def high(eq):
         nonlocal maxnum
         if eq.name == "f_pow" and eq.children[1].name[:2] == "d_":
             n = int(eq.children[1].name[2:])
-            if n>power and n % power == 0:
-                 maxnum = max(maxnum, n)
+            if abs(n)>power and abs(n) % power == 0:
+                if abs(n)>abs(maxnum):
+                    maxnum = n
         for child in eq.children:
             high(child)
     def helper(eq):
-        nonlocal maxnum
-        if eq.name == "f_pow" and eq.children[1].name[:2] == "d_":
+        nonlocal maxnum, fx, r
+        if eq.name == "f_pow" and eq.children[1].name[:2] == "d_" and eq.children[0] == curr:
             n = int(eq.children[1].name[2:])
-            sgn = round(abs(n)/n)
-            n = abs(n)
-            if n>power and n % power == 0 and maxnum==n:
-                out= (eq.children[0]**tree_form("d_"+str(sgn*int(n/power))))**power
+            if maxnum !=1 and n % maxnum == 0:
+                fx = lambda x: replace(x, tree_form(r), curr**tree_form("d_"+str(maxnum)))
+                out= tree_form(r)**tree_form("d_"+str(int(n/maxnum)))
                 return out
         return TreeNode(eq.name, [helper(child) for child in eq.children])
-    high(equation)
     out = None
-    if power == 2:
-        out = transform_formula(helper(equation), "v_0", formula_gen2[0], formula_gen2[1], formula_gen2[2])
-    elif power == 3:
-        out = transform_formula(helper(equation), "v_0", formula_gen3[0], formula_gen3[1], formula_gen3[2])
-    elif power == 4:
+    
+    for i in range(2,4):
+        if power == i:
+            for curr in vlist(equation):
+                curr = tree_form(curr)
+                fx = None
+                maxnum = 1
+                high(equation.copy_tree())
+                
+                if maxnum != 1:
+                    maxnum= maxnum/power
+                    maxnum = round(maxnum)
+                eq2 = helper(equation.copy_tree())
+                if not contain(eq2, tree_form(r)) or (contain(eq2, tree_form(r)) and not contain(eq2,curr)):
+                    if not contain(eq2, tree_form(r)):
+                        r = curr.name
+                        fx = lambda x: x
+                        
+                    lst = poly(eq2.copy_tree(), r)
+                    if lst is not None and len(lst)==i+1:
+                        
+                        success = True
+                        if i == 2:
+                            a, b, c = lst
+                            x1 = (-b+(b**2 - 4*a*c)**(tree_form("d_2")**-1))/(2*a)
+                            x2 = (-b-(b**2 - 4*a*c)**(tree_form("d_2")**-1))/(2*a)
+                            x1 = simplify(x1)
+                            x2 = simplify(x2)
+                            eq2 = a*(tree_form(r)-x1)*(tree_form(r)-x2)
+                            if not complexnum and (contain(x1, tree_form("s_i")) or contain(x2, tree_form("s_i"))):
+                                success = False
+                        else:
+                            a, b, c, d = lst
+                            B, C, D =  b/a, c/a, d/a
+                            p = C-(B**2)/3
+                            q = 2*B**3/27-B*C/3+D
+                            t = q**2/4+ p**3/27
+                            u = (-q/2+t**(tree_form("d_2")**-1))**(tree_form("d_3")**-1)
+                            v = (-q/2-t**(tree_form("d_2")**-1))**(tree_form("d_3")**-1)
+                            y1 = u+v
+                            three = 3**(tree_form("d_2")**-1)
+                            y2 = -(u+v)/2+tree_form("s_i")*three*(u-v)/2
+                            y3 = -(u+v)/2-tree_form("s_i")*three*(u-v)/2
+                            x1,x2,x3 = y1-B/3 , y2-B/3, y3-B/3
+                            x1,x2, x3 = simplify(x1), simplify(x2), simplify(x3)
+                            out2 = None
+                            if not complexnum:
+                                for item in itertools.combinations([x1,x2,x3],2):
+                                    if all(contain(item2,tree_form("s_i")) for item2 in list(item)):
+                                        out2 = (tree_form(r)-item[0])*(tree_form(r)-item[1])
+                                        break
+                            if out2 is not None:
+                                out2 = simplify(expand(simplify(out2)))
+                                out3 = None
+                                for item in [x1, x2, x3]:
+                                    if not contain(item,tree_form("s_i")):
+                                        out3 = item
+                                        break
+                                eq2 = a*(tree_form(r)-out3)*out2
+                                
+                            else:
+                                eq2 = a*(tree_form(r)-x1)*(tree_form(r)-x2)*(tree_form(r)-x3)
+                        if success:
+                            equation = fx(eq2)
+                            break
+    
+    if power == 4:
+        
         out = transform_formula(helper(equation), "v_0", formula_gen9[0], formula_gen9[1], formula_gen9[2])
+    
     if out is not None:
         out = simplify(solve(out))
     if out is not None and (complexnum or (not complexnum and not contain(out, tree_form("s_i")))):
         return out
+    
     return TreeNode(equation.name, [factor_helper(child, complexnum, power) for child in equation.children])
-def factor(equation, complexnum=False):
-    return solve(take_common2(simplify(factor_helper(simplify(equation), complexnum, 2))))
+def factor(equation):
+    return solve(take_common2(simplify(equation)))
 def factor2(equation, complexnum=False):
     return solve(factor_helper(solve(factor_helper(simplify(factor_helper(simplify(equation), complexnum, 2)), complexnum, 3)), complexnum, 4))

{mathai-0.4.6 → mathai-0.4.8}/mathai/integrate.py

@@ -31,8 +31,13 @@ def integrate_summation(equation):
 def subs_heuristic(eq, var):
     output = []
     def collect2(eq):
+        if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]) == Fraction(1,2):
+            
+            if eq.children[0] == var:
+                output.append(str_form(eq))
         if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]).denominator == 1 and abs(frac(eq.children[1]).numerator) % 2 == 0:
-            output.append(str_form(eq.children[0]**2))
+            if len(eq.children[0].children) == 0 or eq.children[0].children[0] == var:
+                output.append(str_form(eq.children[0]**2))
         if eq.name in ["f_pow", "f_sin", "f_cos", "f_arcsin"] and var.name in str_form(eq.children[0]):
             if eq.children[0].name[:2] != "v_":
                 output.append(str_form(eq.children[0]))
@@ -57,7 +62,20 @@ def subs_heuristic(eq, var):
     
     tmp = list(set([simplify(tree_form(x)) for x in output]))
     tmp = sorted(tmp, key=lambda x: len(str(x)))
-    return tmp
+    poly_term = None
+    term_degree = 100
+    output = []
+    for item in tmp:
+        n = poly(simplify(item), var.name)
+        if n is None:
+            output.append(item)
+        else:
+            if term_degree > len(n):
+                poly_term = item
+                term_degree = len(n)
+    if poly_term is None:
+        return tmp
+    return [poly_term]+output
 try_index = []
 try_lst = []
 def ref(eq):
@@ -170,7 +188,7 @@ def integrate_subs(equation, term, v1, v2):
         
         return none
 
-    return TreeNode("f_subs", [TreeNode("f_integrate", [simplify(fraction(expand(simplify(equation)))), tree_form(origv2)]),tree_form(origv2) ,g])
+    return TreeNode("f_subs", [TreeNode("f_integrate", [simplify(equation), tree_form(origv2)]),tree_form(origv2) ,g])
 
 def integrate_subs_main(equation):
     if equation.name == "f_ref":
@@ -359,10 +377,21 @@ def integration_formula_trig():
             [parse("C"), parse("0"), parse("1")], [parse("D"), parse("0"), parse("1")],\
             [parse("E"), parse("0"), parse("1")], [parse("F"), parse("0"), parse("1")]]
     return [formula_list, var, expr]
-
-
 formula_gen4 = integration_formula_trig()
 
+def integration_formula_ex():
+    var = "x"
+    formula_list = [
+        (
+            f"e^(A*{var})*cos(B*{var})",
+            f"e^(A*{var})*(A*cos(B*{var}) + B*sin(B*{var}))/(A^2 + B^2)"
+        )
+    ]
+    formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
+    expr = [[parse("A"), parse("1")], [parse("B"), parse("1")]]
+    return [formula_list, var, expr]
+
+formula_gen11 = integration_formula_ex()
 def rm_const(equation):
     if equation.name == "f_ref":
         return equation
@@ -406,4 +435,9 @@ def integrate_formula(equation):
             if out is not None:
                 
                 return out
+        if "f_cos" in expr_str and contain(integrand, tree_form("s_e")):
+            out = transform_formula(integrand, wrt.name, formula_gen11[0], formula_gen11[1], formula_gen11[2])
+            if out is not None:
+                
+                return out
     return TreeNode(eq2.name, [integrate_formula(child) for child in eq2.children])

{mathai-0.4.6 → mathai-0.4.8}/mathai/limit.py

@@ -14,6 +14,7 @@ def substitute_val(eq, val, var="v_0"):
 
 def subslimit(equation, var):
     equation2 = trig0(replace(equation, var, tree_form("d_0")))
+    
     try:
         tmp = simplify(equation2)
         return simplify(expand(tmp))
@@ -35,6 +36,7 @@ def lhospital(num, den, steps,var):
     logs = []
     
     out = check(num, den, var)
+    
     if isinstance(out, TreeNode):
         return out,[]
     for _ in range(steps):

{mathai-0.4.6 → mathai-0.4.8}/mathai/simplify.py

@@ -168,6 +168,15 @@ def clear_div(eq, denom=False):
     return solve(product(lst2)),sign
 
 def simplify(eq):
+    if "v_" not in str_form(eq):
+        n = frac(eq)
+        if n is not None:
+            if n.numerator == 0:
+                return tree_form("d_0")
+            if n.denominator != 1:
+                return tree_form("d_"+str(n.numerator))/tree_form("d_"+str(n.denominator))
+            else:
+                return tree_form("d_"+str(n.numerator))
     error = False
     eq = flatten_tree(eq)
     if eq.name in ["f_and", "f_or", "f_not"]:
@@ -287,7 +296,9 @@ def simplify(eq):
                 error = True
             else:
                 eq = tree_form("d_0")
-        
+        if eq.name =="f_pow" and eq.children[0] == tree_form("s_i") and frac(eq.children[1])is not None and frac(eq.children[1]).denominator == 1:
+            n = frac(eq.children[1]).numerator
+            eq = {0:tree_form("d_1"), 1:tree_form("s_i"), 2:tree_form("d_-1"), 3:-tree_form("s_i")}[n%4]
         if eq.name == "f_mul":
             dic = {}
             for child in eq.children:

mathai-0.4.8/mathai/tool.py

@@ -0,0 +1,163 @@
+from .diff import diff
+from .expand import expand
+from .simplify import simplify, solve
+from .base import *
+import math
+
+def poly_div(dividend_coeffs, divisor_coeffs):
+    """
+    Perform polynomial division using coefficients with symbolic simplification.
+    """
+    # Deep copy inputs using copy_tree()
+    dividend = [item.copy_tree() for item in dividend_coeffs]
+    divisor = [item.copy_tree() for item in divisor_coeffs]
+    
+    # Remove leading zeros
+    while len(dividend) > 1 and simplify(dividend[0]) == 0:
+        dividend.pop(0)
+    while len(divisor) > 1 and simplify(divisor[0]) == 0:
+        divisor.pop(0)
+    
+    # Validate divisor
+    if len(divisor) == 0 or simplify(divisor[0]) == 0:
+        raise ValueError("Invalid divisor")
+    
+    if len(dividend) < len(divisor):
+        return [tree_form("d_0")], [item.copy_tree() for item in dividend]
+    
+    # Calculate degrees
+    deg_p = len(dividend) - 1
+    deg_q = len(divisor) - 1
+    deg_quot = deg_p - deg_q
+    
+    # Initialize quotient (highest degree first)
+    quotient = [tree_form("d_0")] * (deg_quot + 1)
+    
+    # Working dividend - keep original structure
+    working_dividend = [item.copy_tree() for item in dividend]
+    
+    # Long division - align by current leading terms
+    for k in range(deg_quot, -1, -1):
+        # Remove leading zeros from working dividend
+        while len(working_dividend) > 1 and simplify(working_dividend[0]) == 0:
+            working_dividend.pop(0)
+        
+        if len(working_dividend) == 0 or simplify(working_dividend[0]) == 0:
+            continue
+        
+        # Calculate quotient term for degree k
+        leading_ratio = simplify(working_dividend[0] / divisor[0])
+        quotient[k] = leading_ratio
+        
+        # Subtract leading_ratio * divisor (aligned at leading terms)
+        new_dividend = []
+        for i in range(max(len(working_dividend), len(divisor))):
+            dividend_term = working_dividend[i] if i < len(working_dividend) else tree_form("d_0")
+            divisor_term = simplify(leading_ratio * divisor[i]) if i < len(divisor) else tree_form("d_0")
+            result = simplify(dividend_term - divisor_term)
+            new_dividend.append(result)
+        
+        working_dividend = new_dividend
+    
+    # Remainder is terms with degree < deg_q (last deg_q terms of final dividend)
+    remainder = working_dividend[-(deg_q):] if len(working_dividend) > deg_q else working_dividend
+    while len(remainder) > 1 and simplify(remainder[0]) == 0:
+        remainder.pop(0)
+    if not remainder:
+        remainder = [tree_form("d_0")]
+    
+    # Clean quotient trailing zeros
+    while len(quotient) > 1 and simplify(quotient[-1]) == 0:
+        quotient.pop()
+    
+    return quotient, remainder
+
+def unpoly(eq, var):
+    eq = eq[::-1]
+    eq = [simplify(item) for item in eq]
+    eq2 = copy.deepcopy([eq[i]*tree_form(var)**tree_form("d_"+str(i)) if i != 0 else eq[i] for i in range(len(eq))])
+    return summation(eq2)
+
+def longdiv(p, q, p_min=0, q_min=0):
+    p, q = simplify(p), simplify(q)
+    
+    var = set(vlist(p)) & set(vlist(q))
+    if len(var) > 0:
+        var = list(var)[0]
+        p = poly(p, var)
+        q = poly(q, var)
+        if p is not None and q is not None and len(p)-1>=p_min and len(q)-1>=q_min and len(p)<=len(q):
+            a, b = poly_div(p, q)
+            return unpoly(a, var), unpoly(b, var)
+    return None
+def poly_simplify(eq):
+    a, b = num_dem(eq)
+    b = simplify(b)
+    if b != 1:
+        return simplify(poly_simplify(a)/poly_simplify(b))
+    for var in vlist(eq):
+        n = poly(eq, var, 20)
+        if n is not None:
+            return simplify(unpoly(n, var))
+    return TreeNode(eq.name, [poly_simplify(child) for child in eq.children])
+def enclose_const(eq):
+    def req(eq, dic):
+        for key in dic.keys():
+            eq  = replace(eq, dic[key], key)
+        return eq
+    alloclst = []
+    for i in range(0,26):
+        if "v_"+str(i) not in vlist(eq):
+            alloclst.append(tree_form("v_"+str(i)))
+    dic = {}
+    def helper(eq):
+        nonlocal alloclst, dic
+        if frac(eq) is not None:
+            return eq
+        
+        if "v_" not in str_form(eq):
+            if eq not in dic.keys():
+                n = alloclst.pop(0)
+                dic[eq] = n
+            return dic[eq]
+        else:
+            if eq.name == "f_pow":
+                return TreeNode(eq.name, [helper(eq.children[0]), eq.children[1]])
+            return TreeNode(eq.name, [helper(child) for child in eq.children])
+    eq= helper(eq)
+    return eq, lambda x: req(x, dic)
+
+def poly(eq, to_compute, m=10):
+    def substitute_val(eq, val, var="v_0"):
+        eq = replace(eq, tree_form(var), tree_form("d_"+str(val)))
+        return eq
+    def inv(eq):
+        if eq.name[:2] == "f_" and eq.name[2:] in "ref try integrate subs".split(" "):
+            return False
+        if eq.name[2:] in ["sin", "cos", "log"] and contain(eq.children[0], tree_form(to_compute)):
+            return False
+        if eq.name == "f_pow" and contain(eq.children[0], tree_form(to_compute)) and\
+           (frac(eq.children[1]) is None or frac(eq.children[1]) < 0 or frac(eq.children[1]).denominator != 1):
+            return False
+        if eq.name == "f_abs":
+            return False
+        if any(not inv(child) for child in eq.children):
+            return False
+        return True
+    if not inv(eq):
+        return None
+    out = []
+    eq2 = eq
+    for i in range(m):
+        out.append(expand(simplify(eq2)))
+        eq2 = diff(eq2, to_compute)
+    for i in range(len(out)-1,-1,-1):
+        if out[i] == tree_form("d_0"):
+            out.pop(i)
+        else:
+            break
+    final = []
+    for index, item in enumerate(out):
+        final.append(substitute_val(item, 0, to_compute)/tree_form("d_"+str(math.factorial(index))))
+        
+    return [expand(simplify(item)) for item in final][::-1]

{mathai-0.4.6 → mathai-0.4.8}/mathai/trig.py

@@ -58,6 +58,9 @@ def trig0(eq):
         if a > b:       
             a = 2*b - a
         return a, b
+    if eq.name == "f_arccosec":
+        return (1/eq.children[0]).fx("arcsin")
+    
     if eq.name == "f_arctan":
         if eq.children[0].name == "d_0":
             return tree_form("d_0")
@@ -164,52 +167,61 @@ def _trig1(equation):
     return TreeNode(equation.name, [_trig1(child) for child in equation.children])
 def trig1(eq):
     return simplify(_trig1(noneg_pow(eq)))
-    
-def trig4(eq, numer=True):
-    if eq.name == "f_sin":
-        if eq.children[0].name == "f_add" and len(eq.children[0].children)>=2:
-            r = len(eq.children[0].children)%2
-            a, b = TreeNode("f_add", eq.children[0].children[:round((len(eq.children[0].children)-r)/2)]),\
-                   TreeNode("f_add", eq.children[0].children[round((len(eq.children[0].children)-r)/2):])
-            if len(a.children)==1:
-                a=a.children[0]
-            if len(b.children)==1:
-                b=b.children[0]
-            return a.fx("sin")*b.fx("cos") + a.fx("cos")*b.fx("sin")
-        if eq.children[0].name == "f_arccos":
-            a = eq.children[0].children[0]
-            return (1-a**2)**(tree_form("d_2")**-1)
-        if eq.children[0].name == "f_arctan":
-            a = eq.children[0].children[0]
-            return a/(1+a**2)**(tree_form("d_2")**-1)
-    if eq.name == "f_pow" and numer:
-        if eq.children[0].name == "f_cos":
-            a = eq.children[0].children[0]
-            if frac(eq.children[1]) == 2:
-                return 1 - a.fx("sin")**2
-        if eq.children[0].name == "f_sin":
-            a = eq.children[0].children[0]
-            if frac(eq.children[1]) == 2:
-                return 1 - a.fx("cos")**2
-    if eq.name == "f_cos":
-        if eq.children[0].name == "f_add" and len(eq.children[0].children)>=2:
-            r = len(eq.children[0].children)%2
-            a, b = TreeNode("f_add", eq.children[0].children[:round((len(eq.children[0].children)-r)/2)]),\
-                   TreeNode("f_add", eq.children[0].children[round((len(eq.children[0].children)-r)/2):])
-            if len(a.children)==1:
-                a=a.children[0]
-            if len(b.children)==1:
-                b=b.children[0]
-            return a.fx("cos")*b.fx("cos") - a.fx("sin")*b.fx("sin")
-        if eq.children[0].name == "f_arcsin":
-            a = eq.children[0].children[0]
-            return (1-a**2)**(tree_form("d_2")**-1)
-        if eq.children[0].name == "f_arctan":
-            a = eq.children[0].children[0]
-            return tree_form("d_1")/(1+a**2)**(tree_form("d_2")**-1)
-    
-    return TreeNode(eq.name, [trig4(child, False) if not numer or (eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]) < 0) else trig4(child, True) for child in eq.children])
-
+def trig4(eq):
+    done = False
+    def _trig4(eq, numer=True, chance="sin"):
+        nonlocal done
+        if eq.name == "f_sin":
+            if eq.children[0].name == "f_add" and len(eq.children[0].children)>=2:
+                r = len(eq.children[0].children)%2
+                a, b = TreeNode("f_add", eq.children[0].children[:round((len(eq.children[0].children)-r)/2)]),\
+                       TreeNode("f_add", eq.children[0].children[round((len(eq.children[0].children)-r)/2):])
+                if len(a.children)==1:
+                    a=a.children[0]
+                if len(b.children)==1:
+                    b=b.children[0]
+                return a.fx("sin")*b.fx("cos") + a.fx("cos")*b.fx("sin")
+            if eq.children[0].name == "f_arccos":
+                a = eq.children[0].children[0]
+                return (1-a**2)**(tree_form("d_2")**-1)
+            if eq.children[0].name == "f_arctan":
+                a = eq.children[0].children[0]
+                return a/(1+a**2)**(tree_form("d_2")**-1)
+        if eq.name == "f_pow" and numer:
+            if eq.children[0].name == "f_cos" and chance == "cos":
+                a = eq.children[0].children[0]
+                if frac(eq.children[1]) == 2:
+                    done = True
+                    return 1 - a.fx("sin")**2
+            if eq.children[0].name == "f_sin" and chance == "cos":
+                a = eq.children[0].children[0]
+                if frac(eq.children[1]) == 2:
+                    done = True
+                    return 1 - a.fx("cos")**2
+        if eq.name == "f_cos":
+            if eq.children[0].name == "f_add" and len(eq.children[0].children)>=2:
+                r = len(eq.children[0].children)%2
+                a, b = TreeNode("f_add", eq.children[0].children[:round((len(eq.children[0].children)-r)/2)]),\
+                       TreeNode("f_add", eq.children[0].children[round((len(eq.children[0].children)-r)/2):])
+                if len(a.children)==1:
+                    a=a.children[0]
+                if len(b.children)==1:
+                    b=b.children[0]
+                return a.fx("cos")*b.fx("cos") - a.fx("sin")*b.fx("sin")
+            if eq.children[0].name == "f_arcsin":
+                a = eq.children[0].children[0]
+                return (1-a**2)**(tree_form("d_2")**-1)
+            if eq.children[0].name == "f_arctan":
+                a = eq.children[0].children[0]
+                return tree_form("d_1")/(1+a**2)**(tree_form("d_2")**-1)
+        
+        return TreeNode(eq.name, [_trig4(child, False, chance) if eq.name != "f_add" and\
+                                  (not numer or (eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]) < 0))\
+                                   else _trig4(child, True, chance) for child in eq.children])
+    eq= _trig4(eq)
+    if not done:
+        eq = _trig4(eq,"cos")
+    return eq
 def trig2(eq):
     # Base case: if not an addition, recurse into children
     if eq.name != "f_add":
@@ -245,4 +257,3 @@ def trig2(eq):
 
     # If no sin/cos pairs found, just recurse on children
     return TreeNode(eq.name, [trig2(child) for child in eq.children])
-

{mathai-0.4.6 → mathai-0.4.8}/mathai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.4.6
+Version: 0.4.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
@@ -16,6 +16,9 @@ Dynamic: requires-python
 Dynamic: summary
 
 # Math AI Documentation
+## Source
+Github repository of the code
+https://github.com/infinity390/mathai4
 
 ## Philosophy
 I think it is a big realization in computer science and programming to realize that computers can solve mathematics.  

{mathai-0.4.6 → mathai-0.4.8}/setup.py

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

mathai-0.4.6/mathai/tool.py

@@ -1,62 +0,0 @@
-from .diff import diff
-from .expand import expand
-from .simplify import simplify
-from .base import *
-import math
-
-def enclose_const(eq):
-    def req(eq, dic):
-        for key in dic.keys():
-            eq  = replace(eq, dic[key], key)
-        return eq
-    alloclst = []
-    for i in range(0,26):
-        if "v_"+str(i) not in vlist(eq):
-            alloclst.append(tree_form("v_"+str(i)))
-    dic = {}
-    def helper(eq):
-        nonlocal alloclst, dic
-        if frac(eq) is not None:
-            return eq
-        
-        if "v_" not in str_form(eq):
-            if eq not in dic.keys():
-                n = alloclst.pop(0)
-                dic[eq] = n
-            return dic[eq]
-        else:
-            if eq.name == "f_pow":
-                return TreeNode(eq.name, [helper(eq.children[0]), eq.children[1]])
-            return TreeNode(eq.name, [helper(child) for child in eq.children])
-    eq= helper(eq)
-    return eq, lambda x: req(x, dic)
-
-def poly(eq, to_compute):
-    def substitute_val(eq, val, var="v_0"):
-        eq = replace(eq, tree_form(var), tree_form("d_"+str(val)))
-        return eq
-    def inv(eq):
-        if eq.name == "f_pow" and "v_" in str_form(eq.children[0]) and eq.children[1] == tree_form("d_-1"):
-            return False
-        if eq.name == "f_abs":
-            return False
-        if any(not inv(child) for child in eq.children):
-            return False
-        return True
-    if not inv(eq):
-        return None
-    out = []
-    eq2 = eq
-    for i in range(10):
-        out.append(expand(simplify(eq2)))
-        eq2 = diff(eq2, to_compute)
-    for i in range(len(out)-1,-1,-1):
-        if out[i] == tree_form("d_0"):
-            out.pop(i)
-        else:
-            break
-    final = []
-    for index, item in enumerate(out):
-        final.append(substitute_val(item, 0, to_compute)/tree_form("d_"+str(math.factorial(index))))
-        
-    return [expand(simplify(item)) for item in final][::-1]