mathai 0.2.2__tar.gz → 0.2.4__tar.gz

{mathai-0.2.2 → mathai-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mathai
-Version: 0.2.2
+Version: 0.2.4
 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.2.2 → mathai-0.2.4}/mathai/__init__.py

@@ -1,7 +1,7 @@
 from .expand import expand
 from .parser import parse
 from .printeq import printeq, printeq_log, printeq_str
-from .simplify import solve, simplify
+from .simplify import solve, simplify, solve2
 from .integrate import integrate, sqint, byparts
 from .diff import diff
 from .factor import factor, factor2
@@ -12,4 +12,5 @@ from .logic import logic0, logic1, logic2, logic3
 from .apart import apart
 from .console import console
 from .limit import limit
+from .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt
 from .base import *

{mathai-0.2.2 → mathai-0.2.4}/mathai/base.py

@@ -193,7 +193,8 @@ def compute(eq):
 
     # Recursive case: compute child values
     values = [compute(child) for child in eq.children]
-
+    if None in values:
+        return None
     # Evaluate based on node type
     if eq.name == "f_add":
         return sum(values)

{mathai-0.2.2 → mathai-0.2.4}/mathai/expand.py

@@ -52,5 +52,7 @@ def expand(eq):
                 add = add + mul
                 add = simplify(add)
             eq = add
+        eq = simplify(eq)
+        
     return TreeNode(eq.name, [expand(child) for child in eq.children])
 

{mathai-0.2.2 → mathai-0.2.4}/mathai/inverse.py

@@ -1,10 +1,11 @@
 from .base import *
 from .simplify import solve
 from .expand import expand
-def inverse(rhs,term):
+def inverse(rhs,term, sign=None):
     term = tree_form(term)
     lhs = tree_form("d_0")
     count = 15
+    
     while not rhs==term:
         if rhs.name == "f_add":
             if all(term in factor_generation(child) for child in rhs.children):
@@ -20,6 +21,12 @@ def inverse(rhs,term):
             for i in range(len(rhs.children)-1,-1,-1):
                 if not contain(rhs.children[i], term):
                     lhs = lhs * rhs.children[i]**-1
+                    if sign is not None:
+                        if "v_" in str_form(rhs.children[i]):
+                            return None
+                        if compute(rhs.children[i]**-1) < 0:
+                            sign = not sign
+                    
                     rhs.children.pop(i)
         elif rhs.name == "f_pow" and contain(rhs.children[0], term):
             lhs = lhs ** (tree_form("d_1")/rhs.children[1])
@@ -53,5 +60,6 @@ def inverse(rhs,term):
         count -= 1
         if count == 0:
             return None
-    
-    return solve(lhs)
+    if sign is None:
+        return solve(lhs)
+    return solve(lhs), sign

{mathai-0.2.2 → mathai-0.2.4}/mathai/limit.py

@@ -23,19 +23,22 @@ def subslimit(equation, var):
 def check(num, den, var):
     n, d = None, None
     
-    n, d = (dowhile(replace(e, var, tree_form("d_0")), lambda x: trig0(simplify(x))) for e in (num, den))
+    n, d = (dowhile(replace(e, tree_form(var), tree_form("d_0")), lambda x: trig0(simplify(x))) for e in (num, den))
+
     if n is None or d is None:
         return False
     if n == 0 and d == 0: return True
-    if d != 0: return simplify(num/den)
+    if d != 0:
+        return simplify(n/d)
     return False
 def lhospital(num, den, steps,var):
     logs = []
+    
     out = check(num, den, var)
     if isinstance(out, TreeNode):
         return out,[]
     for _ in range(steps):
-        num2, den2 = map(lambda e: simplify(diff(e, var.name)), (num, den))
+        num2, den2 = map(lambda e: simplify(diff(e, var)), (num, den))
         out = check(num2, den2, var)
         if out is True:
             num, den = num2, den2
@@ -49,7 +52,7 @@ def lhospital2(eq, var):
     eq=  simplify(eq)
     if eq is None:
         return None
-    if not contain(eq, var):
+    if not contain(eq, tree_form(var)):
         return eq,[]
     num, dem = [simplify(item) for item in num_dem(eq)]
     if num is None or dem is None:
@@ -110,14 +113,15 @@ def approx(eq, var):
 def approx_limit(equation, var):
     return dowhile(equation, lambda x: approx(x, var))
 
-def limit(equation, var=tree_form("v_0")):
+def limit(equation, var="v_0"):
     logs = [(0,"lim x->0 "+printeq_str(simplify(equation)))]
-    eq2 = dowhile(replace(equation, var, tree_form("d_0")), lambda x: trig0(simplify(x)))
-    if eq2 is not None and not contain(equation, var):
+    eq2 = dowhile(replace(equation, tree_form(var), tree_form("d_0")), lambda x: trig0(simplify(x)))
+    if eq2 is not None and not contain(equation, tree_form(var)):
         return eq2,logs
+    
     equation, tmp = lhospital2(equation, var)
     equation = simplify(expand(simplify(equation)))
-    if not contain(equation, var):
+    if not contain(equation, tree_form(var)):
         return equation,logs+tmp
     '''
     if equation.name == "f_add":

{mathai-0.2.2 → mathai-0.2.4}/mathai/simplify.py

@@ -144,25 +144,36 @@ def solve(eq, specialfx=False):
     eq = flatten_tree(eq)
     
     return dowhile(eq, _solve)
-
+def solve2(eq):
+    return solve(eq, True)    
 def clear_div(eq):
     lst = factor_generation(eq)
     if tree_form("d_0") in lst:
         return tree_form("d_0")
-    lst = [item for item in lst if not(item.name == "f_pow" and frac(item.children[1]) is not None and frac(item.children[1]) < 0)]
+    lst3 = [item for item in lst if "v_" not in str_form(item) and compute(item) < 0]
+    sign = True
+    if len(lst3) % 2 == 1:
+        sign = False
+    lst = [item for item in lst if not(item.name == "f_pow" and frac(item.children[1]) is not None and frac(item.children[1]) == -1)]
 
     lst2 = [item for item in lst if "v_" in str_form(item)]
     if lst2 == []:
-        return solve(product(lst))
-    return solve(product(lst2))
+        return solve(product(lst)),sign
+    return solve(product(lst2)),sign
 
 def simplify(eq):
     error = False
-    if eq.name == "f_eq":
-        if eq.children[1] != 0:
-            return TreeNode(eq.name, [clear_div(simplify(eq.children[0]-eq.children[1])), tree_form("d_0")])
-        else:
-            return TreeNode(eq.name, [clear_div(simplify(eq.children[0])), tree_form("d_0")])
+    eq = flatten_tree(eq)
+    if eq.name in ["f_and", "f_or", "f_not"]:
+        return TreeNode(eq.name, [simplify(child) for child in eq.children])
+        
+    if eq.name in ["f_lt", "f_gt", "f_le", "f_ge", "f_eq"]:
+        tmp, sign = clear_div(simplify(eq.children[0]-eq.children[1]))
+        name2 = eq.name
+        if not sign:
+            name2 = {"f_lt":"f_gt", "f_gt":"f_lt", "f_eq":"f_eq", "f_le":"f_ge", "f_ge":"f_le"}[name2]
+
+        return TreeNode(name2, [tmp, tree_form("d_0")])
 
     eq = solve(eq, True)
     def helper(eq):
@@ -219,6 +230,8 @@ def simplify(eq):
         return TreeNode(eq.name, [helper3(child) for child in eq.children])
     def helper4(eq):
         nonlocal error
+        if eq == tree_form("d_-1")**tree_form("d_-1"):
+            return tree_form("d_-1")
         def perfect_nth_root_value(x, n):
             """Return integer y if x is a perfect n-th power (y**n == x), else None."""
             if x < 0 and n % 2 == 0:
@@ -316,6 +329,8 @@ def simplify(eq):
             return eq.children[0].children[0]**eq.children[1]
         return TreeNode(eq.name, [helper5(child) for child in eq.children])
     def helper8(eq):
+        if eq.name == "f_pow" and eq.children[0].name == "f_abs" and frac(eq.children[1]) is not None and frac(eq.children[1]).numerator % 2==0:
+            return eq.children[0].children[0] ** eq.children[1]
         if eq.name == "f_abs" and eq.children[0].name == "f_abs":
             return eq.children[0]
         if eq.name == "f_cos" and eq.children[0].name == "f_abs":

mathai-0.2.4/mathai/univariate_inequality.py

@@ -0,0 +1,411 @@
+import itertools
+
+from .base import *
+from .inverse import inverse
+from collections import Counter
+from .factor import factor2
+from .simplify import simplify, solve
+from .expand import expand
+from .fraction import fraction
+import copy
+from .diff import diff
+from .logic import logic0
+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
+
+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 = 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]
+
+            tmp2 = diff(copy.deepcopy(item))
+            if "v_" in str_form(tmp2):
+                return None
+
+            
+            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 compute(a) < 0:
+                    sign = not sign
+                continue
+            
+            
+            if compute(tmp2)<0:
+                sign = not sign
+                item = simplify(item * tree_form("d_-1"))
+            out = inverse(item, vlist(item)[0])
+            critical.append(out)
+        else:
+            tmp2 = diff(copy.deepcopy(item))
+            if "v_" in str_form(tmp2):
+                return None
+            
+            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 compute(a) < 0:
+                    sign = not sign
+                continue
+            
+            
+            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(str_form(out))
+    equal = list(set([simplify(tree_form(item)) for item in equal]))
+    more = list(set([simplify(tree_form(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):
+    if equation.name in ["f_and", "f_or", "f_not"]:
+        tmp = TreeNode(equation.name, [absolute(child) for child in equation.children])
+        if len(tmp.children)==1:
+            tmp =tmp.children[0]
+        return tmp
+    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.children[0])
+            return out
+        for child in eq.children:
+            out += collectabs(child)
+        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)))
+    
+    out2 = []
+    for item in itertools.product([0,1,2], repeat=len(out)):
+        out3 = []
+        for i in range(len(item)):
+            out3.append(copy.deepcopy(TreeNode({0:"f_gt", 1:"f_lt", 2:"f_eq"}[item[i]], [out[i], tree_form("d_0")])))
+        out3 = TreeNode("f_and", out3+[abc(copy.deepcopy(equation), list(item))])
+        if len(out3.children) == 1:
+            out3 = out3.children[0]
+        out2.append(out3)
+    if len(out2) == 1:
+        return out2[0]
+    else:
+        equation = TreeNode("f_or", out2)
+    return equation
+def handle_sqrt(eq):
+    eq = domain(eq)
+    def helper2(eq):
+        if eq.name in ["f_lt", "f_gt", "f_le", "f_ge"]:
+            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:
+                
+                eq2, sgn = inverse(simplify(eq.children[0]), str_form(item), True)
+                n = tree_form("d_1")
+                if sgn == False:
+                    n = tree_form("d_-1")
+                eq3 = simplify(expand(simplify(eq2**2)))
+                eq2 = simplify(eq2)
+                if "v_" in str_form(eq3) and not (eq2.name == "f_pow" and frac(eq2.children[1]) == Fraction(1,2)):
+                    return simplify(TreeNode(eq.name, [simplify(n*item.children[0]-eq3*n), tree_form("d_0")])) & TreeNode("f_ge", [eq2, tree_form("d_0")])
+                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])
+    return helper2(eq)
+def domain(eq):
+    eq = solve(eq, True)
+    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:
+            out.append(TreeNode("f_ge", [eq.children[0], tree_form("d_0")]))
+        if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]) <0:
+            out.append(TreeNode("f_eq", [eq.children[0], tree_form("d_0")]).fx("not"))
+        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.2.2 → mathai-0.2.4}/mathai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mathai
-Version: 0.2.2
+Version: 0.2.4
 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.2.2 → mathai-0.2.4}/mathai.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ mathai/simplify.py
 mathai/structure.py
 mathai/tool.py
 mathai/trig.py
+mathai/univariate_inequality.py
 mathai.egg-info/PKG-INFO
 mathai.egg-info/SOURCES.txt
 mathai.egg-info/dependency_links.txt

{mathai-0.2.2 → mathai-0.2.4}/setup.py

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