mathai 0.6.0__py3-none-any.whl

mathai/univariate_inequality.py

@@ -0,0 +1,458 @@
+import itertools
+
+from .base import *
+from .inverse import inverse
+from collections import Counter
+#from .factor import factor2
+from .simplify import simplify
+from .expand import expand
+from .fraction import fraction
+import copy
+from .diff import diff
+from .logic import logic0
+from .tool import poly, poly_simplify
+def intersection2(domain, lst):
+    domain = copy.deepcopy(domain)
+    if domain == [True]:
+        return lst
+    elif domain == [True]:
+        return []
+    lst = [item for item in lst if item not in domain]
+    out = []
+    
+    for item2 in lst:
+        for index in range(len(domain)):
+            
+            if isinstance(domain[index], bool) and domain[index]:
+                
+                if index == 0 and compute(item2) < compute(domain[index+1]):
+                    
+                    out.append(item2)
+                    break
+                elif index == len(domain)-1 and compute(domain[index-1]) < compute(item2):
+                    out.append(item2)
+                    break
+                elif index != 0 and index != len(domain)-1 and compute(domain[index-1]) < compute(item2) and compute(item2) < compute(domain[index+1]):
+                    
+                    out.append(item2)
+                    break
+                
+    return list(set(out))
+def flip_less_than(inter):
+    inter = copy.deepcopy(inter)
+    return [not item if isinstance(item, bool) else item for item in inter]
+def intersection(domain_1, domain_2):
+    domain_1, domain_2 = copy.deepcopy(domain_1), copy.deepcopy(domain_2)
+    if domain_1 == [True]:
+        return domain_2
+    if domain_2 == [True]:
+        return domain_1
+    if domain_1 == [False] or domain_2 == [False]:
+        return [False]
+    def simplify_ranges(ranges):
+        simplified_ranges = []
+        i = 0
+        while i < len(ranges):
+            if i + 2 < len(ranges) and ranges[i] is True and ranges[i + 2] is True:
+                simplified_ranges.append(True)
+                i += 3
+            elif i + 2 < len(ranges) and ranges[i] is False and ranges[i + 2] is False:
+                simplified_ranges.append(False)
+                i += 3
+            else:
+                simplified_ranges.append(ranges[i])
+                i += 1
+        return simplified_ranges
+    result = domain_1 + domain_2
+    result = [item for item in result if not isinstance(item, bool)]
+    result = list(set(result))
+    result = sorted(result, key=lambda x: compute(x))
+    i = len(result)
+    while i>=0:
+        result.insert(i, True)
+        i = i - 1
+    result[0] = domain_1[0] and domain_2[0]
+    result[-1] = domain_1[-1] and domain_2[-1]
+    def find_fraction_in_list(fraction_list, target_fraction):
+        for i in range(1, len(fraction_list)-1, 2):
+            if fraction_list[i] == target_fraction:
+                return i
+        return -1
+    for i in range(2, len(result)-1, 2):
+        if result[i+1] in domain_1:
+            result[i] = result[i] and domain_1[find_fraction_in_list(domain_1, result[i+1])-1]
+        if result[i+1] in domain_2:
+            result[i] = result[i] and domain_2[find_fraction_in_list(domain_2, result[i+1])-1]
+        if result[i-1] in domain_1:
+            result[i] = result[i] and domain_1[find_fraction_in_list(domain_1, result[i-1])+1]
+        if result[i-1] in domain_2:
+            result[i] = result[i] and domain_2[find_fraction_in_list(domain_2, result[i-1])+1]
+
+    result = simplify_ranges(result)
+    return result
+class Range:
+    def __init__(self, r=[True], p=[], z=[]):
+        self.r = r
+        self.p = p
+        self.z = z
+        self.do = True
+        
+    def unfix(self):
+        self.do = False
+        return self
+    def fix(self):
+        if not self.do:
+            return
+        def simplify_ranges(ranges):
+            simplified_ranges = []
+            i = 0
+            while i < len(ranges):
+                if i + 2 < len(ranges) and ranges[i] is True and ranges[i + 2] is True:
+                    simplified_ranges.append(True)
+                    i += 3
+                elif i + 2 < len(ranges) and ranges[i] is False and ranges[i + 2] is False:
+                    simplified_ranges.append(False)
+                    i += 3
+                else:
+                    simplified_ranges.append(ranges[i])
+                    i += 1
+            return simplified_ranges
+        
+        self.r = simplify_ranges(self.r)
+        
+        common = set(self.p) & set(self.z)
+        self.z = list(set(self.z) - common)
+        self.p = list(set(self.p) - common)
+        
+        self.p = list(set(self.p) - set(intersection2(self.r, self.p)))
+        self.z = list(set(intersection2(self.r, self.z)))
+        return self
+        
+    def __or__(self, other):
+        return (self.unfix().__invert__().unfix() & other.unfix().__invert__().unfix()).unfix().__invert__().fix()
+    def __invert__(self):
+        tmp =  Range(flip_less_than(self.r), self.z, list(set(self.p)-set(self.z)))
+
+        return tmp
+    def __and__(self, other):
+        a = intersection(self.r, other.r)
+        b = intersection2(self.r, other.p)
+        c = intersection2(other.r, self.p)
+        tmp = Range(a, list(set(b)|set(c)|(set(self.p)&set(other.p))), list(set(self.z)|set(other.z)))
+        return tmp
+    def __str__(self):
+
+        if self.r == [False] and self.p == [] and self.z == []:
+            return "{}"
+        out = []
+        out2 = ""
+        if self.r != [False]:
+            for i in range(0, len(self.r), 2):
+                string = ""
+                if self.r[i]:
+                    if i == 0:
+                        string += "(-inf,"
+                        if len(self.r)==1:
+                            string += "+inf)"
+                        else:
+                            string += str(self.r[i+1])+")"
+                    elif i == len(self.r)-1 and len(self.r)!=1:
+                        string += "("+str(self.r[i-1])+",+inf)"
+                    else:
+                        string += "("+str(self.r[i-1])+","+str(self.r[i+1])+")"
+                    out.append(string)
+        if self.p != []:
+            out.append("{"+",".join([str(item) for item in self.p])+"}")
+        if self.z != []:
+            out2 = "{"+",".join([str(item) for item in self.z])+"}"
+        if out2 == "":
+            return "U".join(out)
+        else:
+            return "U".join(out)+"-"+out2
+def prepare(eq):
+    if eq.name[2:] in "and not or".split(" "):
+        output = TreeNode(eq.name, [])
+        for child in eq.children:
+            out = prepare(child)
+            if out is None:
+                return None
+            output.children.append(out)
+        output = TreeNode(output.name, output.children)
+        return output
+    elif eq.name[2:] in "gt lt eq ge le".split(" "):
+        eq = simplify(eq)
+        out = prepare(eq.children[0])
+        if out is None:
+            return None
+        output = TreeNode(eq.name, [out, tree_form("d_0")])
+        
+        output = logic0(output)
+        return output
+    else:
+        eq = logic0(eq)
+        if eq.name in ["s_true", "s_false"]:
+            return eq
+        if len(vlist(eq)) != 1:
+            if "v_" not in str_form(eq):
+                return eq
+            return None
+        out = poly(eq, vlist(eq)[0])
+        if out is None or len(out) > 3:
+            
+            output = []
+            for item in factor_generation(eq):
+                if item.name == "f_pow" and item.children[1].name == "d_-1":
+                    out2 = poly(item.children[0], vlist(eq)[0])
+                    if out2 is not None and len(out2) <= 3:
+                        output.append(poly_simplify(item.children[0])**-1)
+                    else:
+                        return None
+                else:
+                    out2 = poly(item, vlist(eq)[0])
+                    if out2 is not None and len(out2) <= 3:
+                        output.append(poly_simplify(item))
+                    else:
+                        return None
+            return simplify(product(output))
+        else:
+            return poly_simplify(eq)
+    
+dic_table = {}
+def helper(eq, var="v_0"):
+    global dic_table
+    
+    eq2 = copy.deepcopy(eq)
+    
+    if eq2 in dic_table.keys():
+        return dic_table[eq2]
+    
+    if eq.children[0].name == "f_add":
+        
+        eq.children[0] = simplify(expand(eq.children[0]))
+        #eq = simplify(factor2(eq))
+    
+        
+    equ = False
+    sign= True
+    if eq.name in ["f_gt", "f_ge"]:
+        sign = True
+    elif eq.name in ["f_lt", "f_le"]:
+        sign = False
+    if eq.name in ["f_ge", "f_le"]:
+        equ = True
+    if eq.name == "f_eq":
+        equ= True
+    critical = []
+    equal = []
+    more = []
+    
+    _, d = num_dem(eq.children[0])
+    d = simplify(d)
+    
+    #d = factor2(d)
+    
+    for item in factor_generation(d):
+         
+        item = simplify(expand(item))
+        if len(vlist(item)) != 0:
+            v = vlist(item)[0]
+            if diff(diff(item, v), v) != tree_form("d_0"):
+                continue
+            out = inverse(item, vlist(item)[0])
+            more.append(simplify(out))
+    
+    #eq.children[0] = factor2(eq.children[0])
+    
+    for item in factor_generation(eq.children[0]):
+        item = simplify(expand(item))
+        
+        if len(vlist(item)) == 0:
+            if compute(item) <0:
+                sign = not sign
+            continue
+        v = vlist(item)[0]
+        
+        if item.name == "f_pow" and item.children[1].name== "d_-1":
+            
+            item = item.children[0]
+            
+            if diff(diff(item, v), v) != tree_form("d_0"):
+                
+                a = replace(diff(diff(item, v), v), tree_form(v), tree_form("d_0"))/tree_form("d_2")
+                if "v_" in str_form(a):
+                    return None
+                if compute(a) < 0:
+                    sign = not sign
+                continue
+            else:
+                tmp2 = diff(copy.deepcopy(item))
+                if compute(tmp2)<0:
+                    sign = not sign
+                    item = simplify(item * tree_form("d_-1"))
+                out = inverse(item, vlist(item)[0])
+                critical.append(out)
+        else:
+            
+            
+            if diff(diff(item, v), v) != tree_form("d_0"):
+                a = replace(diff(diff(item, v), v), tree_form(v), tree_form("d_0"))/tree_form("d_2")
+                if "v_" in str_form(a):
+                    return None
+                if compute(a) < 0:
+                    sign = not sign
+                continue
+            else:
+                tmp2 = diff(copy.deepcopy(item))
+                if compute(tmp2)<0:
+                    sign = not sign
+                    item = simplify(item * tree_form("d_-1"))
+                out = inverse(item, vlist(item)[0])
+                critical.append(out)
+                if equ:
+                    equal.append(out)
+    equal = list(set([simplify(item) for item in equal]))
+    more = list(set([simplify(item) for item in more]))
+    critical = [simplify(item) for item in critical]
+    
+    critical = Counter(critical)
+    
+    critical = sorted(critical.items(), key=lambda x: compute(x[0]))
+
+    i = len(critical)
+    element = sign
+    while i>=0:
+        critical.insert(i, element)
+        if i>0 and critical[i-1][1] % 2 != 0:
+            element = not element
+        i = i - 1
+    for i in range(1, len(critical), 2):
+        critical[i] = critical[i][0]
+
+    
+    if eq.name == "f_eq":
+        final = Range([False], equal, more)
+        dic_table[eq2] = final
+        return final
+  
+    final = Range(critical, equal, more)
+    dic_table[eq2] = final
+    return final
+def wavycurvy(eq):
+    if eq.name == "s_true":
+        return Range([True])
+    if eq.name == "s_false":
+        return Range([False])
+    if eq.name not in ["f_and", "f_or", "f_not"]:
+        
+        out = helper(eq)
+        if out is None:
+            return None
+        return out
+    lst= [wavycurvy(child) for child in eq.children]
+    if None in lst:
+        return None
+    ra = lst[0]
+    if eq.name == "f_and":
+        for child in lst[1:]:
+            ra = ra & child
+    elif eq.name == "f_or":
+        for child in lst[1:]:
+            ra = ra | child
+    elif eq.name == "f_not":
+        ra = ~ra
+    return ra
+
+def absolute(equation):
+    def mul_abs(eq):
+        if eq.name == "f_abs" and eq.children[0].name == "f_mul":
+            return simplify(product([item.fx("abs") for item in factor_generation(eq.children[0])]))
+        return TreeNode(eq.name, [mul_abs(child) for child in eq.children])
+    equation = mul_abs(equation)
+            
+    def collectabs(eq):
+        out = []
+        if eq.name == "f_abs":
+            
+            out.append(eq)
+            return out
+        for child in eq.children:
+            out += collectabs(child)
+            if out != []:
+                return out
+        return out
+    def abc(eq, arr):
+        def trans(eq):
+            nonlocal arr
+            out = {}
+            if eq.name == "f_abs":
+                x = arr.pop(0)
+                if x == 0 or x==2:
+                    return eq.children[0]
+                else:
+                    return -eq.children[0]
+            else:  
+                return TreeNode(eq.name, [trans(child) for child in eq.children])
+        return trans(eq)
+    out = list(set(collectabs(equation)))
+    if out == []:
+        return logic0(equation)
+    else:
+        a = TreeNode("f_ge", [out[0].children[0], tree_form("d_0")]) & replace(equation, out[0], out[0].children[0])
+        b = TreeNode("f_lt", [out[0].children[0], tree_form("d_0")]) & replace(equation, out[0], -out[0].children[0])
+        return a | b
+def handle_sqrt(eq):
+    d= []
+    def helper2(eq):
+        nonlocal d
+        if eq.name in ["f_lt", "f_gt", "f_le", "f_ge","f_eq"]:
+            out = []
+            def helper(eq):
+                nonlocal out
+                if eq.name == "f_pow" and frac(eq.children[1]) == Fraction(1,2):
+                    out.append(simplify(eq))
+                x = [helper(child) for child in eq.children]
+            helper(eq)
+            for item in out:
+                n = tree_form("d_1")
+                if eq.name == "f_eq":
+                    eq2 = inverse(simplify(eq.children[0]), str_form(item))
+                else:
+                    eq2, sgn = inverse(simplify(eq.children[0]), str_form(item), True)
+                    if sgn == False:
+                        n = tree_form("d_-1")
+                d.append(TreeNode("f_ge", [eq2,tree_form("d_0")]))
+                #d.append(TreeNode("f_ge", [item.children[0],tree_form("d_0")]))
+                eq3 = simplify(expand(simplify(eq2**2)))
+                
+                return simplify(TreeNode(eq.name, [simplify(n*item.children[0]-eq3*n), tree_form("d_0")]))
+            
+        return TreeNode(eq.name, [helper2(child) for child in eq.children])
+    out = helper2(eq)
+    if len(d) == 0:
+        return out
+    return TreeNode("f_and", [helper2(eq)]+d)
+def domain(eq):
+    eq = simplify(eq)
+    out = []
+    def helper2(eq):
+        nonlocal out
+        if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]).denominator == 2:
+            if "v_" in str_form(eq.children[0]):
+                out.append(TreeNode("f_ge", [eq.children[0], tree_form("d_0")]))
+                out.append(TreeNode("f_ge", [eq, tree_form("d_0")]))
+        if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]) <0:
+            tmp = TreeNode("f_eq", [eq.children[0], tree_form("d_0")]).fx("not")
+            if "v_" in str_form(tmp):
+                out.append(tmp)
+        x = [helper2(child) for child in eq.children]
+    helper2(eq)
+    out = list(set([simplify(item) for item in out]))
+    if out == []:
+        return eq
+    if len(out)==1:
+        out = out[0]
+    else:
+        out = TreeNode("f_and", list(out))
+    if eq.name in ["f_lt", "f_gt", "f_le", "f_ge", "f_eq"]:
+        return eq & out
+    return out

mathai-0.6.0.dist-info/METADATA

@@ -0,0 +1,234 @@
+Metadata-Version: 2.4
+Name: mathai
+Version: 0.6.0
+Summary: Mathematics solving Ai tailored to NCERT
+Home-page: https://github.com/infinity390/mathai4
+Author: educated indians are having a low iq and are good for nothing
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: lark-parser
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+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.  
+This understanding should be made mainstream. It can help transform education, mathematical research, and computation of mathematical equations for work.
+
+## Societal Implications Of Such A Computer Program And The Author's Comment On Universities Of India
+I think mathematics is valued by society because of education. Schools and universities teach them.  
+So this kind of software, if made mainstream, could bring real change.
+
+### The Author's Comments On The Universities In His Country
+> Educated Indians are having a low IQ and are good for nothing.  
+> The Indian Institute of Technology (IITs) graduates are the leader of the fools.  
+> Every educated Indian is beneath me.  
+> Now learn how this Python library can solve the math questions of your exams.
+
+## The Summary Of How Computer "Solves" Math
+Math equations are a tree data structure (`TreeNode` class).  
+We can manipulate the math equations using various algorithms (functions provided by the `mathai` library).  
+We first parse the math equation strings to get the tree data structure (`parse` function in `mathai`).
+
+## The Library
+Import the library by doing:
+
+```python
+from mathai import *
+```
+
+### str_form
+It is the string representation of a `TreeNode` math equation.
+
+#### Example
+```text
+(cos(x)^2)+(sin(x)^2)
+```
+
+Is represented internally as:
+
+```text
+f_add
+ f_pow
+  f_cos
+   v_0
+  d_2
+ f_pow
+  f_sin
+   v_0
+  d_2
+```
+
+#### Leaf Nodes
+
+**Variables** (start with a `v_` prefix):
+
+- `v_0` -> x
+- `v_1` -> y
+- `v_2` -> z
+- `v_3` -> a
+
+**Numbers** (start with `d_` prefix; only integers):
+
+- `d_-1` -> -1
+- `d_0` -> 0
+- `d_1` -> 1
+- `d_2` -> 2
+
+#### Branch Nodes
+- `f_add` -> addition
+- `f_mul` -> multiplication
+- `f_pow` -> power
+
+### parse
+Takes a math equation string and outputs a `TreeNode` object.
+
+```python
+from mathai import *
+
+equation = parse("sin(x)^2+cos(x)^2")
+print(equation)
+```
+
+#### Output
+```text
+(cos(x)^2)+(sin(x)^2)
+```
+
+### printeq, printeq_str, printeq_log
+Prints math equations in a more readable form than usual `print`.
+
+```python
+from mathai import *
+
+equation = simplify(parse("(x+1)/x"))
+print(equation)
+printeq(equation)
+```
+
+#### Output
+```text
+(1+x)*(x^-1)
+(1+x)/x
+```
+
+### solve, simplify
+`simplify` performs what `solve` does and more.  
+It simplifies and cleans up a given math equation.
+
+```python
+from mathai import *
+
+equation = simplify(parse("(x+x+x+x-1-1-1-1)*(4*x-4)*sin(sin(x+x+x)*sin(3*x))"))
+printeq(equation)
+```
+
+#### Output
+```text
+((-4+(4*x))^2)*sin((sin((3*x))^2))
+```
+
+### Incomplete Documentation, Will be updated and completed later on
+
+### Example Demonstration [limits questions can also be solved other than this these, try limit()]
+![pip-install-mathai-mathematics-solving-ai-system-in-python-v0-xcg3c22k51sf1](https://github.com/user-attachments/assets/799f576f-27d0-4d7c-86e9-ad55ff221bcc)
+```python
+import sys, os, time
+from mathai import *
+
+sys.setrecursionlimit(10000)
+
+def integration_byparts(item): return simplify(fraction(simplify(byparts(simplify(parse(item)))[0])))
+def integration_apart(item): return simplify(fraction(integrate(apart(factor2(simplify(parse(item)))))[0]))
+def integration_direct(item): return simplify(fraction(simplify(integrate(simplify(parse(item)))[0])))
+def integration_trig(item): return simplify(trig0(integrate(trig1(simplify(parse(item))))[0]))
+def algebra(item): return logic0(simplify(expand(simplify(parse(item)))))
+def trig_basic(item): return logic0(simplify(expand(trig3(simplify(parse(item))))))
+def trig_advanced(item): return logic0(simplify(trig0(trig1(trig4(simplify(fraction(trig0(simplify(parse(item))))))))))
+
+all_tasks = [
+    *[(item, trig_advanced) for item in [
+        "cos(x)/(1+sin(x)) + (1+sin(x))/cos(x) = 2*sec(x)",
+        "(1+sec(x))/sec(x) = sin(x)^2/(1-cos(x))"]],
+    *[(item, integration_byparts) for item in ["sin(x)*x","x*sin(3*x)","x*log(abs(x))","arctan(x)"]],
+    *[(item, integration_apart) for item in ["x/((x+1)*(x+2))","1/(x^2-9)"]],
+    *[(item, integration_direct) for item in [
+        "x*sqrt(x+2)","sin(cos(x))*sin(x)","2*x/(1+x^2)","sqrt(a*x+b)","cos(sqrt(x))/sqrt(x)","e^(arctan(x))/(1+x^2)","sqrt(sin(2*x))*cos(2*x"]], 
+    *[(item, integration_trig) for item in ["sin(2*x+5)^2","sin(x)^4","cos(2*x)^4"]],
+    *[(item, algebra) for item in ["(x+1)^2 = x^2+2*x+1","(x+1)*(x-1) = x^2-1"]],
+    *[(item, trig_basic) for item in ["2*sin(x)*cos(x)=sin(2*x)"]],
+]
+
+def run_task(task):
+    item, func = task
+    try: result = func(item)
+    except Exception as e: result = str(e)
+    return item, result
+
+if __name__=="__main__":
+    print(f"Solving {len(all_tasks)} math questions...\n")
+    start_time = time.time()
+    for task in all_tasks:
+        item, result = run_task(task)
+        print(f"{item}  =>  {result}\n")
+    print(f"All tasks completed in {time.time()-start_time:.2f} seconds")
+```
+### Output
+
+```
+Running 21 tasks asynchronously on 8 cores...
+
+x*log(abs(x))  =>  ((-2*(x^2))+(4*log(abs(x))*(x^2)))*(8^-1)
+
+arctan(x)  =>  (log((abs((1+(x^2)))^-1))+(2*arctan(x)*x))*(2^-1)
+
+sin(cos(x))*sin(x)  =>  cos(cos(x))
+
+1/(x^2-9)  =>  (log(abs((-3+x)))+log((abs((3+x))^-1)))*(6^-1)
+
+x/((x+1)*(x+2))  =>  log((abs((1+x))^-1))+log(((2+x)^2))
+
+x*sin(3*x)  =>  ((-9*cos((3*x))*x)+(3*sin((3*x))))*(27^-1)
+
+(1+sec(x))/sec(x) = sin(x)^2/(1-cos(x))  =>  true
+
+e^(arctan(x))/(1+x^2)  =>  e^arctan(x)
+
+cos(sqrt(x))/sqrt(x)  =>  2*sin((x^(2^-1)))
+
+sqrt(a*x+b)  =>  2*(3^-1)*(((x*a)+b)^(3*(2^-1)))*(a^-1)
+
+sin(x)*x  =>  (-1*cos(x)*x)+sin(x)
+
+(x+1)^2 = x^2+2*x+1  =>  true
+
+(x+1)*(x-1) = x^2-1  =>  true
+
+cos(x)/(1+sin(x)) + (1+sin(x))/cos(x) = 2*sec(x)  =>  true
+
+2*sin(x)*cos(x)=sin(2*x)  =>  true
+
+sqrt(sin(2*x))*cos(2*x)  =>  (3^-1)*(sin((2*x))^(3*(2^-1)))
+
+2*x/(1+x^2)  =>  log(abs((1+(x^2))))
+
+sin(2*x+5)^2  =>  ((-1*(4^-1)*sin((10+(4*x))))+x)*(2^-1)
+
+cos(2*x)^4  =>  ((4^-1)*x)+((64^-1)*sin((8*x)))+((8^-1)*sin((4*x)))+((8^-1)*x)
+
+x*sqrt(x+2)  =>  ((-1*(4^-1)*((2+x)^(2+(2^-1))))+(-2*((2+x)^(2+(2^-1))))+(5*((2+x)^(1+(2^-1)))*x)+((2^-1)*((2+x)^(1+(2^-1)))*x)+((8^-1)*((2+x)^(1+(2^-1)))*x))*((1+(2^-1))^-3)*((2+(2^-1))^-1)
+
+sin(x)^4  =>  (-1*(4^-1)*sin((2*x)))+((32^-1)*sin((4*x)))+((4^-1)*x)+((8^-1)*x)
+
+All tasks completed in 129.78 seconds
+```
+