mathai 0.4.5__tar.gz → 0.4.7__tar.gz

{mathai-0.4.5 → mathai-0.4.7}/PKG-INFO

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

@@ -1,3 +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
@@ -20,6 +25,8 @@ from .diff import diff
 
 from .factor import factor as factor1
 from .factor import factor2
+from .factor import rationalize_sqrt as rationalize
+from .factor import merge_sqrt
 from .factor import factorconst as factor0
 
 from .fraction import fraction

{mathai-0.4.5 → mathai-0.4.7}/mathai/base.py

@@ -253,6 +253,7 @@ def num_dem(equation):
         else:
             num = num*item
     return [num, tree_form("d_1")/den]
+
 def summation(lst):
     if lst == []:
         return tree_form("d_0")

mathai-0.4.7/mathai/factor.py

@@ -0,0 +1,275 @@
+import itertools
+from .parser import parse
+from .structure import transform_formula
+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):
+    counters = list(map(Counter, lists))
+    common = counters[0]
+    for c in counters[1:]:
+        common = common & c
+    return list(common.elements())
+def subtract_sublist(full_list, sublist):
+    c_full = Counter(full_list)
+    c_sub = Counter(sublist)
+    result = c_full - c_sub
+    tmp = list(result.elements())
+    if tmp == []:
+        return [tree_form("d_1")]
+    return tmp
+def term_common2(eq):
+    if eq.name != "f_add":
+        return eq
+    s = []
+    arr = [factor_generation(child) for child in eq.children]
+    s = multiset_intersection(*arr)
+    return product(s)*summation([product(subtract_sublist(factor_generation(child), s)) for child in eq.children])
+def term_common(eq):
+    if eq.name == "f_add":
+        return solve(term_common2(eq))
+    return solve(product([term_common2(item) for item in factor_generation(eq)]))
+def take_common(eq):
+    if eq.name == "f_add":
+        eq = term_common(eq)
+        if eq.name == "f_add":
+            for i in range(len(eq.children)-1,1,-1):
+                for item in itertools.combinations(range(len(eq.children)), i):
+                    eq2 = summation([item2 for index, item2 in enumerate(eq.children) if index in item])
+                    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))
+        return eq
+    return term_common(eq)
+def take_common2(eq):
+    eq = take_common(eq)
+    return TreeNode(eq.name, [take_common2(child) for child in eq.children])
+
+def _factorconst(eq):
+    def hcf_list(numbers):
+        if not numbers:
+            return None  # empty list
+        hcf = numbers[0]
+        for num in numbers[1:]:
+            hcf = math.gcd(hcf, num)
+        return hcf
+    def extractnum(eq):
+        lst = factor_generation(eq)
+        for item in lst:
+            if item.name[:2] == "d_":
+                return int(item.name[2:])
+        return 1
+    n = 1
+    if eq.name == "f_add":
+        n = hcf_list([extractnum(child) for child in eq.children])
+        eq = TreeNode(eq.name, [child/tree_form("d_"+str(n)) for child in eq.children])
+    if n != 1:
+        return tree_form("d_"+str(n))*eq
+    return TreeNode(eq.name, [factorconst(child) for child in eq.children])
+
+def _merge_sqrt(eq):
+    lst= []
+    eq2 = []
+    for child in factor_generation(eq):
+        if frac(child) is not None and frac(child).denominator==1:
+            if frac(child)>0:
+                eq2.append(child**2)
+            elif frac(child)!=-1:
+                eq2.append((-child)**2)
+                lst.append(tree_form("d_-1"))
+            else:
+                lst.append(tree_form("d_-1"))
+        elif child.name == "f_pow" and frac(child.children[1]) == Fraction(1,2):
+            eq2.append(child.children[0])
+        else:
+            lst.append(child)
+            
+    if len(eq2)>1:
+        if lst == []:
+            lst= [tree_form("d_1")]
+        return simplify(product(eq2)**(tree_form("d_2")**-1)*product(lst))
+    return TreeNode(eq.name, [_merge_sqrt(child) for child in eq.children])
+def sqrt_to_a_sqrt_b(n):
+    if n == 0:
+        return 0, 0
+    sign = 1
+    if n < 0:
+        sign = -1
+        m = -n
+    else:
+        m = n
+
+    a = 1
+    b = 1
+    p = 2
+    while p * p <= m:
+        exp = 0
+        while m % p == 0:
+            m //= p
+            exp += 1
+        if exp:
+            a *= p ** (exp // 2)
+            if exp % 2 == 1:
+                b *= p
+        p += 1 if p == 2 else 2
+
+    if m > 1:
+        b *= m
+
+    return sign * a, b
+def merge_sqrt(eq):
+    def helper(eq):
+        if eq.name == "f_pow" and frac(eq.children[1]) == Fraction(1,2):
+            if eq.children[0].name[:2] == "d_":
+                n = int(eq.children[0].name[2:])
+                a, b =sqrt_to_a_sqrt_b(n)
+                return tree_form("d_"+str(b))**(tree_form("d_2")**-1)*tree_form("d_"+str(a))
+        return TreeNode(eq.name, [helper(child) for child in eq.children])
+    return helper(_merge_sqrt(eq))
+def rationalize_sqrt(eq):
+    if eq.name== "f_pow" and frac(eq.children[1]) == Fraction(-1,2):
+        eq = eq.children[0]**(tree_form("d_2")**-1)/eq.children[0]
+    def term(eq):
+        if eq.name == "f_add":
+            output = []
+            for child in eq.children:
+                if any(child2.name == "f_pow" and frac(child2.children[1]) == Fraction(1,2) for child2 in factor_generation(child)):
+                    output.append(simplify(-child))
+                else:
+                    output.append(child)
+            return summation(output)
+        return None
+    n, d=num_dem(eq)
+    n,d=simplify(n), simplify(d)
+   
+    if d != 1:
+        t = term(d)
+        if t is not None and t!=1:
+            
+            n,d=simplify(expand(simplify(n*t))),simplify(expand(simplify(d*t)))
+            tmp= simplify(n/d)
+            
+            tmp = _merge_sqrt(tmp)
+            
+            return tmp
+    return TreeNode(eq.name, [rationalize_sqrt(child) for child in eq.children])
+def factorconst(eq):
+    return simplify(_factorconst(eq))
+
+def factor_quar_formula_init():
+    var = ""
+    formula_list = [(f"(A^4+B*A^2+C)", f"(A^2 + sqrt(2*sqrt(C) - B)*A + sqrt(C))*(A^2 - sqrt(2*sqrt(C) - B)*A + sqrt(C))")]
+    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]
+
+formula_gen9 = factor_quar_formula_init()
+def factor_helper(equation, complexnum, power=2):
+    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 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, fx, r
+        if eq.name == "f_pow" and eq.children[1].name[:2] == "d_":
+            n = int(eq.children[1].name[2:])
+            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])
+    out = None
+    for i in range(2,4):
+        if power == i:
+            for curr in vlist(equation):
+                curr = tree_form(curr)
+                fx = None
+                maxnum = 1
+                high(equation)
+                
+                if maxnum != 1:
+                    maxnum= maxnum/power
+                    maxnum = round(maxnum)
+                eq2 = helper(equation)
+                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 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.5 → mathai-0.4.7}/mathai/integrate.py

@@ -367,7 +367,7 @@ def rm_const(equation):
     if equation.name == "f_ref":
         return equation
     eq2 = equation
-    if eq2.name == "f_integrate":
+    if eq2.name == "f_integrate" and contain(eq2.children[0], eq2.children[1]):
         equation = eq2.children[0]
         wrt = eq2.children[1]
         lst = factor_generation(equation)
@@ -407,4 +407,3 @@ def integrate_formula(equation):
                 
                 return out
     return TreeNode(eq2.name, [integrate_formula(child) for child in eq2.children])
-

mathai-0.4.7/mathai/ode.py

@@ -0,0 +1,124 @@
+from .factor import factor
+from .expand import expand
+from .base import *
+from .fraction import fraction
+from .simplify import simplify
+import copy
+
+def inversediff(lhs, rhs):
+    count = 4
+    while contain(rhs, tree_form("v_1")) or contain(lhs, tree_form("v_0")):
+        success = False
+        if rhs.name == "f_add":
+            for i in range(len(rhs.children)-1,-1,-1):
+                if not contain(rhs.children[i], tree_form("v_0")) or str_form(tree_form("v_1").fx("dif")) in [str_form(x) for x in factor_generation(rhs.children[i])]:
+                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
+                        success = True
+                    lhs = lhs - rhs.children[i]
+                    rhs.children.pop(i)
+        elif rhs.name == "f_mul":
+            for i in range(len(rhs.children)-1,-1,-1):
+                if not contain(rhs.children[i], tree_form("v_0")):
+                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
+                        success = True
+                    lhs = lhs / rhs.children[i]
+                    rhs.children.pop(i)
+        if len(rhs.children) == 1:
+            rhs = rhs.children[0]
+        rhs, lhs = copy.deepcopy([simplify(lhs), simplify(rhs)])
+        if rhs.name == "f_add":
+            for i in range(len(rhs.children)-1,-1,-1):
+                if not contain(rhs.children[i], tree_form("v_1")) or str_form(tree_form("v_0").fx("dif")) in [str_form(x) for x in factor_generation(rhs.children[i])]:
+                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
+                        success = True
+                    lhs = lhs - rhs.children[i]
+                    rhs.children.pop(i)
+        elif rhs.name == "f_mul":
+            for i in range(len(rhs.children)-1,-1,-1):
+                if not contain(rhs.children[i], tree_form("v_1")):
+                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
+                        success = True
+                    lhs = lhs / rhs.children[i]
+                    rhs.children.pop(i)
+        rhs, lhs = copy.deepcopy([simplify(lhs), simplify(rhs)])
+        if not success:
+            lhs, rhs = factor(lhs),factor(rhs)
+        count -= 1
+        if count == 0:
+            return simplify(e0(lhs-rhs))
+    return simplify(e0(lhs-rhs))
+
+intconst = ["v_"+str(i) for i in range(101,150)]
+def allocvar():
+    global intconst
+    return tree_form(intconst.pop(0))
+
+def epowersplit(eq):
+    if eq.name == "f_pow" and eq.children[1].name == "f_add":
+        return product([eq.children[0]**child for child in eq.children[1].children])
+    return TreeNode(eq.name, [epowersplit(child) for child in eq.children])
+def esolve(s):
+    if s.name == "f_add" and "f_log" in str_form(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:
+        return None
+    s = summation(s)
+    s = simplify(e0(s))
+    
+    return groupe(s)
+def e0(eq):
+    return TreeNode("f_eq", [eq, tree_form("d_0")])
+def e1(eq):
+    if eq.name == "f_eq":
+        eq = eq.children[0]
+    return eq
+def groupe(eq):
+    eq = esolve(eq)
+    eq = simplify(eq)
+    eq = fraction(eq)
+    eq = simplify(eq)
+    eq = epowersplit(eq)
+    return 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 = diffsolve_sep2(eq)
+    if eq is None:
+        return orig
+    return eq

{mathai-0.4.5 → mathai-0.4.7}/mathai/simplify.py

@@ -287,7 +287,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:
@@ -384,3 +386,4 @@ def simplify(eq):
     if error:
         return None
     return solve(eq)
+

{mathai-0.4.5 → mathai-0.4.7}/mathai/tool.py

@@ -36,7 +36,12 @@ def poly(eq, to_compute):
         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"):
+        if eq.name =="f_eq":
+            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
@@ -47,7 +52,7 @@ def poly(eq, to_compute):
         return None
     out = []
     eq2 = eq
-    for i in range(10):
+    for i in range(8):
         out.append(expand(simplify(eq2)))
         eq2 = diff(eq2, to_compute)
     for i in range(len(out)-1,-1,-1):

{mathai-0.4.5 → mathai-0.4.7}/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,59 @@ 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 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":

{mathai-0.4.5 → mathai-0.4.7}/mathai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.4.5
+Version: 0.4.7
 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.4.5 → mathai-0.4.7}/mathai.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ mathai/inverse.py
 mathai/limit.py
 mathai/linear.py
 mathai/logic.py
+mathai/ode.py
 mathai/parser.py
 mathai/printeq.py
 mathai/simplify.py

{mathai-0.4.5 → mathai-0.4.7}/setup.py

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

mathai-0.4.5/mathai/factor.py

@@ -1,133 +0,0 @@
-import itertools
-from .parser import parse
-from .structure import transform_formula
-from .base import *
-from .simplify import simplify,solve
-from .expand import expand
-import math
-
-from collections import Counter
-def multiset_intersection(*lists):
-    counters = list(map(Counter, lists))
-    common = counters[0]
-    for c in counters[1:]:
-        common = common & c
-    return list(common.elements())
-def subtract_sublist(full_list, sublist):
-    c_full = Counter(full_list)
-    c_sub = Counter(sublist)
-    result = c_full - c_sub
-    tmp = list(result.elements())
-    if tmp == []:
-        return [tree_form("d_1")]
-    return tmp
-def term_common2(eq):
-    if eq.name != "f_add":
-        return eq
-    s = []
-    arr = [factor_generation(child) for child in eq.children]
-    s = multiset_intersection(*arr)
-    return product(s)*summation([product(subtract_sublist(factor_generation(child), s)) for child in eq.children])
-def term_common(eq):
-    if eq.name == "f_add":
-        return solve(term_common2(eq))
-    return solve(product([term_common2(item) for item in factor_generation(eq)]))
-def take_common(eq):
-    if eq.name == "f_add":
-        eq = term_common(eq)
-        if eq.name == "f_add":
-            for i in range(len(eq.children)-1,1,-1):
-                for item in itertools.combinations(range(len(eq.children)), i):
-                    eq2 = summation([item2 for index, item2 in enumerate(eq.children) if index in item])
-                    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))
-        return eq
-    return term_common(eq)
-def take_common2(eq):
-    eq = take_common(eq)
-    return TreeNode(eq.name, [take_common2(child) for child in eq.children])
-
-def _factorconst(eq):
-    def hcf_list(numbers):
-        if not numbers:
-            return None  # empty list
-        hcf = numbers[0]
-        for num in numbers[1:]:
-            hcf = math.gcd(hcf, num)
-        return hcf
-    def extractnum(eq):
-        lst = factor_generation(eq)
-        for item in lst:
-            if item.name[:2] == "d_":
-                return int(item.name[2:])
-        return 1
-    n = 1
-    if eq.name == "f_add":
-        n = hcf_list([extractnum(child) for child in eq.children])
-        eq = TreeNode(eq.name, [child/tree_form("d_"+str(n)) for child in eq.children])
-    if n != 1:
-        return tree_form("d_"+str(n))*eq
-    return TreeNode(eq.name, [factorconst(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 = ""
-    formula_list = [(f"(A^4+B*A^2+C)", f"(A^2 + sqrt(2*sqrt(C) - B)*A + sqrt(C))*(A^2 - sqrt(2*sqrt(C) - B)*A + sqrt(C))")]
-    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
-    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)
-        for child in eq.children:
-            high(child)
-    def helper(eq):
-        nonlocal maxnum
-        if eq.name == "f_pow" and eq.children[1].name[:2] == "d_":
-            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
-                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:
-        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 factor2(equation, complexnum=False):
-    return solve(factor_helper(solve(factor_helper(simplify(factor_helper(simplify(equation), complexnum, 2)), complexnum, 3)), complexnum, 4))