mathai 0.5.2__py3-none-any.whl → 0.5.4__py3-none-any.whl

mathai/__init__.py

@@ -39,7 +39,7 @@ from .logic import logic0, logic1, logic2, logic3
 
 from .apart import apart, apart2
 
-from .limit import limit
+from .limit import limit1, limit2, limit0, limit3
 
 from .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt
 from .bivariate_inequality import inequality_solve

mathai/base.py

@@ -168,9 +168,11 @@ def factor_generation(eq):
     if eq.name == "f_mul":
         for child in eq.children:
             if child.name == "f_pow":
+                '''
                 if child.children[0].name[:2] == "s_":
                     output.append(child)
                     continue
+                '''
                 if child.children[1].name[:2] != "d_":
                     output.append(child)
                     continue
@@ -332,7 +334,7 @@ def string_equation_helper(equation_tree):
     if equation_tree.name == "f_index":
         return string_equation_helper(equation_tree.children[0])+"["+",".join([string_equation_helper(child) for child in equation_tree.children[1:]])+"]"
     s = "(" 
-    if len(equation_tree.children) == 1 or equation_tree.name[2:] in [chr(ord("A")+i) for i in range(26)]+["subs", "try", "ref", "integrate", "exist", "forall", "sum2", "int", "pdif", "dif", "A", "B", "C", "covariance", "sum"]:
+    if len(equation_tree.children) == 1 or equation_tree.name[2:] in [chr(ord("A")+i) for i in range(26)]+["limitpinf", "subs", "try", "ref","limit", "integrate", "exist", "forall", "sum2", "int", "pdif", "dif", "A", "B", "C", "covariance", "sum"]:
         s = equation_tree.name[2:] + s
     sign = {"f_not":"~", "f_addw":"+", "f_mulw":"*", "f_intersection":"&", "f_union":"|", "f_sum2":",", "f_exist":",", "f_forall":",", "f_sum":",","f_covariance": ",", "f_B":",", "f_imply":"->", "f_ge":">=", "f_le":"<=", "f_gt":">", "f_lt":"<", "f_cosec":"?" , "f_equiv": "<->", "f_sec":"?", "f_cot": "?", "f_dot": ".", "f_circumcenter":"?", "f_transpose":"?", "f_exp":"?", "f_abs":"?", "f_log":"?", "f_and":"&", "f_or":"|", "f_sub":"-", "f_neg":"?", "f_inv":"?", "f_add": "+", "f_mul": "*", "f_pow": "^", "f_poly": ",", "f_div": "/", "f_sub": "-", "f_dif": ",", "f_sin": "?", "f_cos": "?", "f_tan": "?", "f_eq": "=", "f_sqrt": "?"}
     arr = []

mathai/integrate.py

@@ -79,8 +79,10 @@ def subs_heuristic(eq, var):
 try_index = []
 try_lst = []
 def ref(eq):
+    '''
     if eq.name in ["f_try", "f_ref"]:
         return eq
+    '''
     if eq.name  == "f_integrate":
         return TreeNode("f_try", [eq.fx("ref"), eq])
     return TreeNode(eq.name, [ref(child) for child in eq.children])
@@ -98,12 +100,12 @@ def _solve_integrate(eq):
     if eq.name == "f_ref":
         return eq
     if eq.name == "f_subs":
-        if "f_integrate" not in str_form(eq.children[0]):
+        if all(item not in str_form(eq.children[0]) for item in ["f_integrate", "f_subs", "f_try"]):
             return replace(eq.children[0], eq.children[1], eq.children[2])
     
     if eq.name == "f_try":
         for child in eq.children:
-            if "f_integrate" not in str_form(child):
+            if all(item not in str_form(child) for item in ["f_integrate", "f_subs", "f_try"]):
                 return child
     return TreeNode(eq.name, [_solve_integrate(child) for child in eq.children])
 def handle_try(eq):
@@ -131,6 +133,7 @@ def inteq(eq):
                 break
         if eq2 is None:
             return eq
+        printeq(eq)
         for child in eq.children:
             if child.name == "f_ref":
                 output.append(child)
@@ -144,6 +147,8 @@ def inteq(eq):
                         output.append(out)
                 else:
                     output.append(child)
+        printeq(TreeNode("f_try", output))
+        print()
         return TreeNode("f_try", output)
     else:
         return TreeNode(eq.name, [inteq(child) for child in eq.children])
@@ -330,13 +335,20 @@ def byparts(eq):
         lst = factor_generation(eq)
         if len(lst) == 3 and len(list(set(lst))) == 1:
             lst = [(lst[0]**2).copy_tree(), lst[0].copy_tree()]
+        if len(lst) == 3 and len(list(set(lst))) == 2:
+            lst2 = list(set(lst))
+            a, b = lst2
+            a = a**lst.count(a)
+            b = b**lst.count(b)
+            lst = [a.copy_tree(), b.copy_tree()]
         if len(lst) == 1:
             lst += [tree_form("d_1")]
         if len(lst) == 2:
             for i in range(2):
                 
                 f, g = [lst[i], lst[1-i]]
-                
+                if contain(f, tree_form("s_e")):
+                    continue
                 out1 = TreeNode("f_integrate", [g.copy_tree(), wrt])
 
                 

mathai/limit.py

@@ -6,7 +6,7 @@ from .expand import expand
 from .diff import diff
 from .trig import trig0
 from .fraction import fraction
-from .printeq import printeq_str
+from .printeq import printeq
 tab=0
 def substitute_val(eq, val, var="v_0"):
     eq = replace(eq, tree_form(var), tree_form("d_"+str(val)))
@@ -33,100 +33,124 @@ def check(num, den, var):
         return simplify(n/d)
     return False
 def lhospital(num, den, steps,var):
-    logs = []
     
     out = check(num, den, var)
     
     if isinstance(out, TreeNode):
-        return out,[]
+        return out
     for _ in range(steps):
         num2, den2 = map(lambda e: simplify(diff(e, var)), (num, den))
         out = check(num2, den2, var)
         if out is True:
             num, den = num2, den2
-            logs += [(0,"lim x->0 "+printeq_str(simplify(num/den)))]
             continue
         if out is False:
             eq2 = simplify(fraction(simplify(num/den)))
-            return eq2,logs
-        return out,logs
+            return eq2
+        return out
 def lhospital2(eq, var):
     eq=  simplify(eq)
     if eq is None:
         return None
     if not contain(eq, tree_form(var)):
-        return eq,[]
+        return eq
     num, dem = [simplify(item) for item in num_dem(eq)]
     if num is None or dem is None:
-        return eq,[]
+        return eq
     
     return lhospital(num, dem, 10,var)
-ls = [parse("sin(A)"), parse("A^B-1"),parse("log(1+A)"), parse("cos(A)")]
-ls= [simplify(item) for item in ls]
-
-def approx(eq, var):
-    n, d= num_dem(eq)
-    n, d = solve(n), solve(d)
-    n, d = expand(n), expand(d)
-    out = []
-    for equation in [n, d]:
-        for item in factor_generation(equation):
-            tmp = structure(item, ls[0])
-            if tmp is not None and contain(tmp["v_-1"], var):
-                item2 = substitute_val(tmp["v_-1"], 0, var.name)
-                if tree_form("d_0") == expand(simplify(item2)):
-                    equation = equation/item
-                    equation = equation*tmp["v_-1"]
-                    break
-                elif tree_form("d_0") == expand(simplify(tree_form("s_pi") - item2)):
-                    equation = equation/item
-                    equation = equation*(tree_form("s_pi") - tmp["v_-1"])
-                    break
-            tmp = structure(item, ls[1])
-            if tmp is not None and contain(tmp["v_-1"], var) and not contain(tmp["v_-2"], var):
-                item2 = substitute_val(tmp["v_-1"], 0, var.name)
-                item2 = expand(solve(item2))
-                if tree_form("d_0") == item2:
-                    equation = equation/item
-                    equation = solve(equation*tmp["v_-1"]*tmp["v_-2"].fx("log"))
-                    break
-            tmp = structure(item, ls[2])
-            if tmp is not None and contain(tmp["v_-1"], var):
-                                
-                item2 = substitute_val(tmp["v_-1"], 0, var.name)
-                item2 = expand(solve(item2))
-                if tree_form("d_0") == item2:
-                    equation = equation/item
-                    equation = solve(equation*tmp["v_-1"])
-                    break
-            tmp = structure(item, ls[3])
-            if tmp is not None and contain(tmp["v_-1"], var):
-                item2 = substitute_val(item, 0, var.name)
-                
-                if tree_form("d_0") == expand(solve(item2)):
-                    
-                    equation = equation/item
-                    equation = equation*(tree_form("d_1") - tmp["v_-1"]**tree_form("d_2"))
-                    break
+def limit0(equation):
+    if equation.name == "f_ref":
+        return equation
+    eq2 = equation
+    g = ["f_limit", "f_limitpinf", "f_limitninf"]
+    if eq2.name in g and contain(eq2.children[0], eq2.children[1]):
+        equation = eq2.children[0]
+        wrt = eq2.children[1]
+        lst = factor_generation(equation)
+        
+        lst_const = [item for item in lst if not contain(item, wrt)]
+        if lst_const != []:
+            
+            equation = product([item for item in lst if contain(item, wrt)]).copy_tree()
+            const = product(lst_const)
+            const = simplify(const)
+            
+            if not contain(const, tree_form("s_i")):
                 
-        equation = solve(equation)
-        out.append(equation)
-    return simplify(out[0]/out[1])
-def approx_limit(equation, var):
-    return dowhile(equation, lambda x: approx(x, var))
+                return limit0(TreeNode(equation.name,[equation, wrt])) *const
+        equation = eq2
+    return TreeNode(equation.name, [limit0(child)  for child in equation.children])
+def limit2(eq):
+    g = ["f_limit", "f_limitpinf", "f_limitninf"]
+    if eq.name in g and eq.children[0].name == "f_add":
+        eq = summation([TreeNode(eq.name, [child, eq.children[1]]) for child in eq.children[0].children])
+    return TreeNode(eq.name, [limit2(child) for child in eq.children])
+def limit1(eq):
+    if eq.name == "f_limit":
+        a, b = limit(eq.children[0], eq.children[1].name)
+        if b:
+            return a
+        else:
+            return TreeNode(eq.name, [a, eq.children[1]])
+    return TreeNode(eq.name, [limit1(child) for child in eq.children])
+def fxinf(eq):
+    if eq is None:
+        return None
+    if eq.name == "f_add":
+        if tree_form("s_inf") in eq.children and -tree_form("s_inf") in eq.children:
+            return None
+        if tree_form("s_inf") in eq.children:
+            return tree_form("s_inf")
+        if -tree_form("s_inf") in eq.children:
+            return -tree_form("s_inf")
+    if eq.name == "f_mul":
+        lst = factor_generation(eq)
+        if tree_form("s_inf") in lst:
+            eq = TreeNode(eq.name, [dowhile(child, fxinf) for child in eq.children])
+            if None in eq.children:
+                return None
+            lst = factor_generation(eq)
+            if tree_form("d_0") in lst:
+                return tree_form("d_0")
+            lst2 = [item for item in lst if "v_" in str_form(item)]
+            sign = True
+            if len([item for item in lst if "v_" not in str_form(item) and not contain(item, tree_form("s_inf")) and compute(item)<0]) % 2==1:
+                sign = False
+            if lst2 == []:
+                if sign:
+                    return tree_form("s_inf")
+                else:
+                    return -tree_form("s_inf")
+    if eq.name == "f_pow":
+        if "v_" not in str_form(eq.children[0]) and not contain(eq.children[0], tree_form("s_inf")) and compute(eq.children[0])>0:
+            if eq.children[1] == -tree_form("s_inf"):
+                return tree_form("d_0")
+            
+    eq = TreeNode(eq.name, [fxinf(child) for child in eq.children])
+    if None in eq.children:
+        return None
+    return eq
+def limit3(eq):
+    
+    if eq.name == "f_limitpinf":
+        if not contain(eq, eq.children[1]):
+            return eq.children[0]
+        eq2 = replace(eq.children[0], eq.children[1], tree_form("s_inf"))
+        eq2 = dowhile(eq2, fxinf)
+        if not contain(eq2, tree_form("s_inf")) and not contain(eq2, eq.children[1]):
+            return simplify(eq2)
+    return TreeNode(eq.name, [limit3(child) for child in eq.children])
 
 def limit(equation, var="v_0"):
-    logs = [(0,"lim x->0 "+printeq_str(simplify(equation)))]
+    
     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
+        return eq2, True
     
-    equation, tmp = lhospital2(equation, var)
+    equation =  lhospital2(equation, var)
     equation = simplify(expand(simplify(equation)))
     if not contain(equation, tree_form(var)):
-        return equation,logs+tmp
-    '''
-    if equation.name == "f_add":
-        return simplify(summation([limit(child, var) for child in equation.children]))
-    '''
-    return equation,logs+tmp
+        return equation, True
+    
+    return equation, False

mathai/parser.py

@@ -59,7 +59,7 @@ grammar = """
      | ESCAPED_STRING      -> string
      | CAPITAL_ID          -> matrix
 
-FUNC_NAME: "midpoint" | "ref" | "subs" | "try" | "forall" | "imply" | "exist" | "len" | "sum" | "angle" | "line" | "sum2" | "charge" | "electricfield" | "perm" | "point" | "equationrhs" | "transpose" | "equationlhs" | "equation" | "error" | "covariance" | "variance" | "expect" | "mag" | "rad" | "laplace" | "diverge" | "pdif" | "gradient" | "curl" | "point1" | "point2" | "dot" | "point3" | "line1" | "line2" | "line3" | "sin" | "circumcenter" | "eqtri" | "linesegment" | "cos" | "tan" | "log" | "sqrt" | "integrate" | "dif" | "abs" | "cosec" | "sec" | "cot" | "arctan" | "arcsin" | "arccos" | "log10"
+FUNC_NAME: "midpoint" | "ref" | "subs" | "try" | "limit" | "forall" | "limitpinf" | "imply" | "exist" | "len" | "sum" | "angle" | "line" | "sum2" | "charge" | "electricfield" | "perm" | "point" | "equationrhs" | "transpose" | "equationlhs" | "equation" | "error" | "covariance" | "variance" | "expect" | "mag" | "rad" | "laplace" | "diverge" | "pdif" | "gradient" | "curl" | "point1" | "point2" | "dot" | "point3" | "line1" | "line2" | "line3" | "sin" | "circumcenter" | "eqtri" | "linesegment" | "cos" | "tan" | "log" | "sqrt" | "integrate" | "dif" | "abs" | "cosec" | "sec" | "cot" | "arctan" | "arcsin" | "arccos" | "log10"
 
 VARIABLE: /[a-z]/ | "nabla" | "pi" | "kc" | "hbar" | "em" | "ec" | "anot" | "false" | "true"
 
@@ -130,7 +130,7 @@ def parse(equation, funclist=None):
         if tree_node.name == "pass_through":
             return fxchange(tree_node.children[0])
         return TreeNode(
-            "f_" + tree_node.name if tree_node.name in tmp3 + ["try", "ref", "sqrt","imply","forall","exist","exclude","union","intersection","len","index","angle","charge","sum2","electricfield","line","point","sum","transpose","equationrhs","equationlhs","equation","covariance","variance","expect","error","laplace","dot","curl","pdif","diverge","gradient","rad","ge","le","gt","lt","eqtri","linesegment","midpoint","mag","point1","point2","point3","line1","line2","line3","log10","arcsin","arccos","arctan","list","cosec","sec","cot","equiv","or","not","and","circumcenter","eq","sub","add","sin","cos","tan","mul","integrate","dif","pow","div","log","abs"] else "d_" + tree_node.name,
+            "f_" + tree_node.name if tree_node.name in tmp3 + ["limitpinf", "limit", "try", "ref", "sqrt","imply","forall","exist","exclude","union","intersection","len","index","angle","charge","sum2","electricfield","line","point","sum","transpose","equationrhs","equationlhs","equation","covariance","variance","expect","error","laplace","dot","curl","pdif","diverge","gradient","rad","ge","le","gt","lt","eqtri","linesegment","midpoint","mag","point1","point2","point3","line1","line2","line3","log10","arcsin","arccos","arctan","list","cosec","sec","cot","equiv","or","not","and","circumcenter","eq","sub","add","sin","cos","tan","mul","integrate","dif","pow","div","log","abs"] else "d_" + tree_node.name,
             [fxchange(child) for child in tree_node.children]
         )
 

mathai/simplify.py

@@ -173,6 +173,7 @@ 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:
@@ -182,6 +183,9 @@ def simplify(eq):
                 return tree_form("d_"+str(n.numerator))/tree_form("d_"+str(n.denominator))
             else:
                 return tree_form("d_"+str(n.numerator))
+    
+    if contain(eq, tree_form("s_inf")):
+        return eq
     error = False
     eq = flatten_tree(eq)
     if eq.name in ["f_and", "f_or", "f_not"]:
@@ -301,6 +305,7 @@ 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]

{mathai-0.5.2.dist-info → mathai-0.5.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.5.2
+Version: 0.5.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.5.2.dist-info → mathai-0.5.4.dist-info}/RECORD

@@ -1,27 +1,27 @@
-mathai/__init__.py,sha256=GciRnhsCDfd_xjC2VoDWVmbapNtR4YlVGEa4ibJi32w,1514
+mathai/__init__.py,sha256=LNmGQztU8xBh7mjgbPemQZKRXythLwif56rDv3ksjs4,1539
 mathai/apart.py,sha256=VSS3khE9PNuxiRvdU5JDl4IN-KJBSIFjwR17pkhviXI,4197
-mathai/base.py,sha256=Ma1oCRbaZP0bp0Qnt_ZjKAh3rt9nZXQ_rmJL0sAoz5c,12730
+mathai/base.py,sha256=pduS0fRpFZR8O-MP-7lDuq1dU603mwfDpmBcT2FyJgI,12793
 mathai/bivariate_inequality.py,sha256=FJOC2zKU5zWCMybCrhEQ7nVDgRO_w19Zko8WPTaDTSo,11411
 mathai/console.py,sha256=Sn58iwYE79MLEh67s8X3q6vZjw6g7f9XM1T8_dBBR2o,3048
 mathai/diff.py,sha256=YUBpRsz0qmBkq5vGxeGnvR4nMKjdOQiIXlNMxpij2ns,3051
 mathai/expand.py,sha256=SnBltkpIENMGkP0AYmbMlSc4H-CF5RslO2PcBEkn1BQ,3359
 mathai/factor.py,sha256=muPDOcClrqc2XyVlbyIrhiIqI0QxauYL3e2mq3qa6OI,11533
 mathai/fraction.py,sha256=Q2ztsh5Bpz6YhML2QU0tfufbAs0Q6J319AhlzKephIY,4396
-mathai/integrate.py,sha256=ewV46QDD0-oiTWpSkmcpcZhBz9StcntbTV1tBLCo1Wo,16502
+mathai/integrate.py,sha256=LMj7om6vTGbYiUwqN-y11fiD4YR_XMbL33AWgI2893o,16982
 mathai/inverse.py,sha256=QCvDrzKquWsZv-BDAzZd9HnU0c3gZvcc44UztHVO5LQ,2919
-mathai/limit.py,sha256=bn7eofIOJv4AIh0-FmLppZ3DKnGfbwOzXks2XOPTOs0,4932
+mathai/limit.py,sha256=DoTBMGdbc47WPN2yo6XwES6Gc-GDDArDhF5uyDFPSC4,5710
 mathai/linear.py,sha256=Mmmnn4IdnADRMuv6crB0a_Ba2drGUFXOh7eqIIkirYA,5709
 mathai/logic.py,sha256=UvHzRmKcO9AD51tRzHmpNSEhgW5gmaf4XPaQKFjGfC4,9653
 mathai/matrix.py,sha256=dWIXF5oInIL3SZ3naRzKN5ElI5drXJNiVTDM48hfZOw,972
 mathai/ode.py,sha256=zxxTXAOpt7oSsfpgI4vHsCWKXevmM96ZOBZWWs-vj8Y,4801
-mathai/parser.py,sha256=f7bemieFmp0sbup1NlraMLvZDVFvqKGFknEVtlFRMVk,6979
+mathai/parser.py,sha256=K6O5TR1PGl9LbSdGpcbwiwQva8r5-SwZ5fSp84oA8co,7025
 mathai/printeq.py,sha256=gIes-pstFOa6FcnpVIVvkjVKuWdsVdo11LlEnmHhakU,1303
-mathai/simplify.py,sha256=EGyEld0ZpOuHLeMmOKhvv0rTejEWjfkwkNJQx3lHSQc,17127
+mathai/simplify.py,sha256=4-7yps_I_OQBd8NthF96H0R-ofA3cFSxgM4wDE45OvU,17217
 mathai/structure.py,sha256=4Ww2IAx62RcQSO7_17TZES-DjMWBpcFQtL939FBIHwY,4103
 mathai/tool.py,sha256=r8ejBY4Bnk_t8USYQCuxwmmJ4M-5H5OR6A3VbV7W-5w,6066
 mathai/trig.py,sha256=BQd_Gl_u0g5ZuZIwKozuXKbMinqb6K-OYicrtftn7eg,11174
 mathai/univariate_inequality.py,sha256=3Yr7d9mE-mUNkwOPQyFPBDp0-gKkqrpzEYeHFQ8JcXA,15060
-mathai-0.5.2.dist-info/METADATA,sha256=sjO-RkjnEu_-D6ahvZq-z_Ad0ZX9GSkM1qZICMmPcmg,7103
-mathai-0.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mathai-0.5.2.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
-mathai-0.5.2.dist-info/RECORD,,
+mathai-0.5.4.dist-info/METADATA,sha256=WIcw95PJtFwsEyhCKVJJuNpQLUlROTfErTRC76nqUX8,7103
+mathai-0.5.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mathai-0.5.4.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
+mathai-0.5.4.dist-info/RECORD,,