mathai 2.1.0__tar.gz → 2.1.2__tar.gz

{mathai-2.1.0 → mathai-2.1.2}/PKG-INFO

@@ -1,13 +1,15 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.1.0
+Version: 2.1.2
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+Requires-Dist: more_itertools
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 

{mathai-2.1.0 → mathai-2.1.2}/mathai/__init__.py

@@ -3,7 +3,7 @@ from .ode import diffsolve_sep as ode_shift_term
 
 from .pde import pde_sep, want, absorb
 
-from .qm import hydrogen_gse, helium_gse
+from .qm import hydrogen_gse, helium_gse, power_rule
 
 from .lambda_calculus import lambda_expand, lambda_compress, lambda_reduce
 

{mathai-2.1.0 → mathai-2.1.2}/mathai/base.py

@@ -3,6 +3,7 @@ import copy
 from fractions import Fraction
 import math
 import itertools
+import more_itertools
 def transform_dfs(root, func, arg=None):
     if root is None:
         return None
@@ -51,14 +52,18 @@ def transform_dfs_parent(root, func, parent, arg=[]):
     return result_map[root]
 def groupings(lst, k, exclude=None):
     exclude = set(exclude or [])
-    n = len(lst)
-    if k < 1 or k > n:
-        return
-    for cuts in itertools.combinations(range(1, n), k - 1):
-        cuts = (0,) + cuts + (n,)
-        groups = [lst[cuts[i]:cuts[i + 1]] for i in range(k)]
-        if all(len(groups[i]) == 1 for i in exclude):
-            yield groups
+    
+    # Guard against invalid k or out-of-bound exclude indices
+    if k < 1 or k > len(lst) or any(i < 0 or i >= k for i in exclude):
+        return []
+
+    results = []
+    # Generate all contiguous partitions of lst
+    for part in more_itertools.partitions(lst):
+        if len(part) == k and all(len(part[i]) == 1 for i in exclude):
+            results.append(part)
+            
+    return results
 def partitions(lst):
     res = set()
     n = len(lst)

{mathai-2.1.0 → mathai-2.1.2}/mathai/formula_compiler.py

@@ -1,4 +1,5 @@
 import copy
+import more_itertools
 import itertools
 from .base import *
 from .parser import parse
@@ -71,36 +72,14 @@ def structure(
     ignore_list = [item.name for item in ignore_list]
     
     equation = TreeNode("eq", [])
-    def strip_w(s):
-        if s in ["f_addw", "f_mulw", "f_hadamardw", "f_waddw"]:
-            return s[:-1]
-        return s
+    
     def make_treenode_string(name, children):
         return f"TreeNode('{name}',[{','.join(children)}])"
     def helper(equation, formula):
-        nonlocal const_1, var_name, ignore_list, const_var, varlist, associativity, ignore
-        if formula.name.startswith("v_") and formula.name in const_1:
-            cond_1 = TreeNode("f_condition", [])
-            ls = [f"any(contain({equation.name},item) for item in [{','.join(ignore)}])", f"any(contain({equation.name},tree_form(item)) for item in {var_name})"]
-            ls = [TreeNode(h) for h in ls]
-            cond_2 = TreeNode("f_if", [operation("f_wor", ls),TreeNode("False")])
-            
-            if formula.name.startswith("v_") and formula.name in varlist.keys():
-                cond_3 = TreeNode(f"{varlist[formula.name].name} == {equation.name}")
-                cond_1.children += [cond_2, cond_3.fx("else")]
-                return cond_1
-            elif formula.name.startswith("v_") and formula.name not in varlist.keys():
-                varlist[formula.name] = equation
-                cond_3 = TreeNode("True")
-                cond_1.children += [cond_2, cond_3.fx("else")]
-                return cond_1
-        elif formula.name.startswith("v_") and formula.name in ignore_list:
+        nonlocal ignore_list, varlist, associativity, ignore
+        if formula.name.startswith("v_") and formula.name in ignore_list:
             cond_1 = TreeNode("f_condition", [])
-            cond_2 = None
-            if const_var == []:
-                cond_2 = TreeNode("f_if", [TreeNode(f"not {equation.name}.name.startswith('v_')"),TreeNode("False")])
-            else:
-                cond_2 = TreeNode("f_if", [TreeNode(f"not {equation.name}.name.startswith('v_')"),TreeNode("False")])
+            cond_2 = TreeNode("f_if", [TreeNode(f"not {equation.name}.name.startswith('v_')"),TreeNode("False")])
             if formula.name.startswith("v_") and formula.name in varlist.keys():
                 cond_3 = TreeNode(f"{varlist[formula.name].name} == {equation.name}")
                 cond_1.children += [cond_2, cond_3.fx("else")]
@@ -127,18 +106,33 @@ def structure(
                     s += 1
             children = [f"{equation.name}.children[{i}]" for i in range(s)]
             new_children = []
-            for key in formula.children:
-                if key.name in associativity.keys():
-                    n = associativity[key.name]
-                    if n == 1:
-                        new_children.append(children.pop(0))
-                    else:
-                        new_children.append(make_treenode_string(strip_w(formula.name), children[:n]))
-                        children = children[n:]
+            if formula.name in ["f_add", "f_mul"]:
+                target_lengths = []
+                for key in formula.children:
+                    n = 1
+                    if key.name in associativity.keys():
+                        n = associativity[key.name]
+                    target_lengths.append(n)
+                result = [[list(group) for group in more_itertools.split_into(p, target_lengths)] for p in itertools.permutations(children)]
+                if not hasattr(formula, "count"):
+                    formula.count = len(result)-1
                 else:
-                    new_children.append(children.pop(0))
+                    formula.count = formula.count-1
+                result = result[formula.count]
+                new_children = [item[0] if len(item) == 1 else make_treenode_string(formula.name, item) for item in result]
+            else:
+                for key in formula.children:
+                    if key.name in associativity.keys():
+                        n = associativity[key.name]
+                        if n == 1:
+                            new_children.append(children.pop(0))
+                        else:
+                            new_children.append(make_treenode_string(formula.name, children[:n]))
+                            children = children[n:]
+                    else:
+                        new_children.append(children.pop(0))
             cond_1 = TreeNode("f_condition", [])
-            ls = [f"{equation.name}.name != '{strip_w(formula.name)}'",f"len({equation.name}.children) != {s}"]
+            ls = [f"{equation.name}.name != '{formula.name}'",f"len({equation.name}.children) != {s}"]
             ls = [TreeNode(h) for h in ls]
             cond_2 = TreeNode("f_if", [operation("f_wor", ls),\
                                        TreeNode("False")])
@@ -154,29 +148,6 @@ def structure(
             cond_3 = lst
             cond_1.children += [cond_2, cond_3.fx("else")]
             return cond_1
-    def lst(formula):
-        out = set()
-        formula = conversion(formula)
-        def helper_lst(node):
-            if not node.children:
-                return [node]
-            child_groups = [tuple(node.children)]
-            if node.name in ["f_waddw", "f_hadamardw", "f_addw", "f_mulw"]:
-                child_groups = list(itertools.permutations(node.children))
-            results = []
-            for children in child_groups:
-                child_perms = [helper_lst(child) for child in children]
-                for combo in itertools.product(*child_perms):
-                    results.append(TreeNode(node.name, list(combo)))
-            return results
-        for tree in helper_lst(formula):
-            out.add(tree)
-        return list(out)
-    def conversion(node):
-        new_name = node.name + "w" if node.name in ["f_wadd", "f_hadamard", "f_add", "f_mul"] else node.name
-        return TreeNode(
-            new_name, [conversion(child) for child in node.children]
-        )
     def gen_ac(eq, formula_list, ignore_list):
         lst = []
         def merge_unique(dicts):
@@ -189,23 +160,22 @@ def structure(
                     else:
                         merged[key] = value
             return merged
-        def make_eq(f):
+        def make_eq(f, arity):
             nonlocal formula_list, lst, ignore_list
-            if f.name in ["f_addw", "f_mulw", "f_hadamardw", "f_waddw", "f_wmul"]:
+            valid_ops = {"f_add", "f_mul", "f_hadamard", "f_wadd", "f_wmul"}
+            if f.name in valid_ops:
                 lst2 = []
-                for i in range(len(f.children),len(f.children)+arity):
-                    for item in groupings(list(range(i)), len(f.children),\
-                                          [index for index, child in enumerate(f.children)\
-                                           if child.name not in formula_list or child.name in ignore_list]):
-                        dic  ={}
-                        for j in range(len(item)):
-                            if f.children[j].name in formula_list:
-                                dic[f.children[j].name] = len(item[j])
-                        lst2.append(dic)
+                label = [child.name for child in f.children if child.name.startswith("v_")]
+                lst3 = [[1] if child.name in ignore_list else list(range(1,arity+1)) for child in f.children if child.name.startswith("v_")]
+                for item in itertools.product(*lst3):
+                    dic = {}
+                    for index, item2 in enumerate(item):
+                        dic[label[index]] = item2
+                    lst2.append(dic)
                 lst.append(lst2)
             for child in f.children:
-                make_eq(child)
-        make_eq(eq)
+                make_eq(child, arity)
+        make_eq(eq, arity)
         output = []
         for item in itertools.product(*lst):
             out = merge_unique(item)
@@ -233,20 +203,45 @@ def structure(
                         var.name == item[0].name
                         and item[1] == 1
                         for item in forbidden_value
-                    ):
+                    ) or var in negative:
                         return out
                     return out + [1]
                 else:
                     return out
         return out
+    def any_attr(eq):
+        if hasattr(eq, "count"):
+            return True
+        if eq.children == []:
+            return False
+        return any(any_attr(child) for child in eq.children)
+    def tree_count_all_zero(eq):
+        if hasattr(eq, "count") and eq.count == 0:
+            return False
+        if eq.children == []:
+            return True
+        return all(tree_count_all_zero(child) for child in eq.children)
+    def del_count(eq):
+        if hasattr(eq, "count"):
+            del eq.count
+        for child in eq.children:
+            del_count(child)
     formula_lst = []
     ll = []
     sorted_vars = list(sorted(set(vlist(formula))))
+    fv = {}
+    for key, item in forbidden_value:
+        if key not in fv.keys():
+            fv[key] = []
+        fv[key] += [item]
     for item in sorted_vars:
-        if forbidden_value == "forbid" or item in ignore_list:
+        if item in ignore_list:
             ll.append([-100])
             continue
-        output = var_replace(formula, tree_form(item))
+        output = [0,1] if item in var_name else []
+        output = [x for x in output if (tree_form(item) not in fv.keys() or x not in fv[tree_form(item)]) and (item not in negative or x!=1)]
+        if output == []:
+            output = None
         if output is not None:
             ll.append([-100] + list(set(output)))
         else:
@@ -267,65 +262,67 @@ def structure(
                 )
             )
         formula_lst.append((eq_try, eq_var))
-    formula_lst_2 = []
-    for key, item in formula_lst:
-        for item2 in lst(key):
-            formula_lst_2.append((item2, item))
     final_output = ""
-    for item, upd in formula_lst_2:
-        
+    for item, upd in formula_lst:
         hh = gen_ac(item, vlist(item), ignore_list)
         for associativity in hh:
-            varlist = {}
-            ignore = []
-            out2 = helper(copy.deepcopy(equation), copy.deepcopy(item))
-            varlist = {}
-            out = helper(copy.deepcopy(equation), item)
-            varlist.update(upd)
-            d = []
-            for key, item2 in varlist.items():
-                for val in [h[1] for h in forbidden_value if h[0].name == key]:
-                    if item2.name[:2] in ["d_"]:
-                        d.append(TreeNode(f"{item2} != {val}"))
-                    elif item2.name[:2] in ["f_","v_","s_"]:
-                        pass
-                    else:
-                        d.append(TreeNode(f"{item2.name} != {val}"))
-            for item2 in positive:
-                local_pos = copy.deepcopy(item2)
-                for key, item3 in varlist.items():
-                    local_pos = replace(local_pos, tree_form(key), item3)
-                s = print_code2(local_pos)
-                s = f"frac({s}) is not None and frac({s})>=0"
-                d.append(TreeNode(s))
-            for item2 in negative:
-                local_neg = copy.deepcopy(item2)
-                for key, item3 in varlist.items():
-                    local_neg = replace(local_neg, tree_form(key), item3)
-                s = print_code2(local_neg)
-                s = f"frac({s}) is not None and frac({s})<=0"
-                d.append(TreeNode(s))
-            if len(d) == 0:
-                pass
-            elif len(d) == 1:
-                out = TreeNode("f_condition", [
-                    TreeNode("f_if", [out, d[0]]),
-                    tree_form("s_false").fx("else")
-                ])
-            else:
-                out = TreeNode("f_condition", [
-                    TreeNode("f_if", [out, TreeNode("f_wand", d)]),
-                    tree_form("s_false").fx("else")
-                ])
-            local_formula_out = copy.deepcopy(formula_out)
-            for key, item2 in varlist.items():
-                local_formula_out = replace(
-                    local_formula_out, tree_form(key), item2
-                )
-            out = TreeNode("f_wand", [out2, out])
-            s = "\tif " + print_code(out) + ":\n"
-            t = "\t\treturn " + print_code2(local_formula_out) + "\n"
-            final_output += s + t
+            while tree_count_all_zero(item):
+                ignore = []
+                varlist = copy.deepcopy(upd)
+                out = helper(copy.deepcopy(equation), item)
+                d = []
+                for key, item2 in varlist.items():
+                    if key in const_1:
+                        if item2.name.startswith("d_"):
+                            d.append(TreeNode(f"all(not contain(TreeNode('{item2}'),item) for item in [{','.join(ignore)}])"))
+                        else:
+                            d.append(TreeNode(f"all(not contain({item2},item) for item in [{','.join(ignore)}])"))
+                for key, item2 in varlist.items():
+                    for val in [h[1] for h in forbidden_value if h[0].name == key]:
+                        if item2.name[:2] in ["d_"]:
+                            d.append(TreeNode(f"{item2} != {val}"))
+                        elif item2.name[:2] in ["f_","v_","s_"]:
+                            pass
+                        else:
+                            d.append(TreeNode(f"{item2.name} != {val}"))
+                for item2 in positive:
+                    local_pos = copy.deepcopy(item2)
+                    for key, item3 in varlist.items():
+                        local_pos = replace(local_pos, tree_form(key), item3)
+                    s = print_code2(local_pos)
+                    s = f"frac({s}) is not None and frac({s})>=0"
+                    d.append(TreeNode(s))
+                for item2 in negative:
+                    local_neg = copy.deepcopy(item2)
+                    for key, item3 in varlist.items():
+                        local_neg = replace(local_neg, tree_form(key), item3)
+                    s = print_code2(local_neg)
+                    s = f"frac({s}) is not None and frac({s})<=0"
+                    d.append(TreeNode(s))
+                if len(d) == 0:
+                    pass
+                elif len(d) == 1:
+                    out = TreeNode("f_condition", [
+                        TreeNode("f_if", [out, d[0]]),
+                        tree_form("s_false").fx("else")
+                    ])
+                else:
+                    out = TreeNode("f_condition", [
+                        TreeNode("f_if", [out, TreeNode("f_wand", d)]),
+                        tree_form("s_false").fx("else")
+                    ])
+                local_formula_out = copy.deepcopy(formula_out)
+                for key, item2 in varlist.items():
+                    local_formula_out = replace(
+                        local_formula_out, tree_form(key), item2
+                    )
+                
+                s = "\tif " + print_code(out) + ":\n"
+                t = "\t\treturn " + print_code2(local_formula_out) + "\n"
+                final_output += s + t
+                if not any_attr(item):
+                    break
+            del_count(item)
     return final_output
 def print_condition(eq):
     assert eq.name == "f_condition"

{mathai-2.1.0 → mathai-2.1.2}/mathai/formula_data.py

@@ -16,43 +16,46 @@ formula_data = {}
 # negative constraint
 # associative arity
 formula = """
-a*x^2+b*x+c true x _ [a,b,c] _ [a,0] _ _ 2
-a*x+b true x _ [a,b] _ [a,0] _ _ 4
+a*x^2+b*x+c true x [a,b] [a,b,c] _ [a,0] _ _ 2
+a*x+b true x [a,b] [a,b] _ [a,0] _ _ 4
 a false _ _ _ _ _ _ _ 1
 // is_integrate_subs
 
-integrate(x^2*e^(a*x+b),x) ((x^2/a)-(2*x/(a^2))+(2/(a^3)))*e^(a*x+b) x _ [a,b] _ [a,0] _ _ 6
-integrate(x*e^(a*x+b),x) ((x/a)-(1/(a^2)))*e^(a*x+b) x _ [a,b] _ [a,0] _ _ 6
-integrate(e^(a*x+b),x) e^(a*x+b)/a x _ [a,b] _ [a,0] _ _ 6
-integrate(1/(a*x+b),x) log(abs(a*x+b))/a x _ [a,b] _ [a,0] _ _ 6
-integrate((a*x+b)^c,x) (a*x+b)^(c+1)/(a*(c+1)) x _ [a,b,c] _ [[a,0],[c,-1]] _ _ 1
-integrate(1/cos(a*x+b)^2,x) tan(a*x+b)/a x _ [a,b] _ [a,0] _ _ 2
-integrate(1/sin(a*x+b)^2,x) -cot(a*x+b)/a x _ [a,b] _ [a,0] _ _ 2
-integrate(1/cos(a*x+b),x) log(abs((1+sin(a*x+b))/cos(a*x+b)))/a x _ [a,b] _ [a,0] _ _ 2
-integrate(1/sin(a*x+b),x) log(abs(tan((a*x+b)/2)))/a x _ [a,b] _ [a,0] _ _ 2
-integrate(sin(a*x+b)^2/cos(a*x+b)^2,x) tan(a*x+b)/a-x x _ [a,b] _ [a,0] _ _ 2
-integrate(sin(a*x+b)/(cos(a*x+b)^2),x) 1/(a*cos(a*x+b)) x _ [a,b] _ [a,0] _ _ 2
-integrate(sin(a*x+b),x) -cos(a*x+b)/a x _ [a,b] _ [a,0] _ _ 6
-integrate(cos(a*x+b),x) sin(a*x+b)/a x _ [a,b] _ [a,0] _ _ 6
-integrate(x,x) x^2/2 x _ _ _ _ _ _ 6
+d*a^(b+c) d*a^b*a^c _ d _ _ [d,0] _ _ 3
+// power_rule
+
+integrate(x^2*e^(a*x+b),x) ((x^2/a)-(2*x/(a^2))+(2/(a^3)))*e^(a*x+b) x [a,b] [a,b] _ [a,0] _ _ 3
+integrate(x*e^(a*x+b),x) ((x/a)-(1/(a^2)))*e^(a*x+b) x [a,b] [a,b] _ [a,0] _ _ 3
+integrate(e^(a*x+b),x) e^(a*x+b)/a x [a,b] [a,b] _ [a,0] _ _ 2
+integrate(1/(a*x+b),x) log(abs(a*x+b))/a x [a,b] [a,b] _ [a,0] _ _ 3
+integrate((a*x+b)^c,x) (a*x+b)^(c+1)/(a*(c+1)) x [a,b] [a,b,c] _ [[a,0],[c,-1]] _ _ 1
+integrate(1/cos(a*x+b)^2,x) tan(a*x+b)/a x [a,b] [a,b] _ [a,0] _ _ 2
+integrate(1/sin(a*x+b)^2,x) -cot(a*x+b)/a x [a,b] [a,b] _ [a,0] _ _ 2
+integrate(1/cos(a*x+b),x) log(abs((1+sin(a*x+b))/cos(a*x+b)))/a x [a,b] [a,b] _ [a,0] _ _ 2
+integrate(1/sin(a*x+b),x) log(abs(tan((a*x+b)/2)))/a x [a,b] [a,b] _ [a,0] _ _ 2
+integrate(sin(a*x+b)^2/cos(a*x+b)^2,x) tan(a*x+b)/a-x x [a,b] [a,b] _ [a,0] _ _ 2
+integrate(sin(a*x+b)/(cos(a*x+b)^2),x) 1/(a*cos(a*x+b)) x [a,b] [a,b] _ [a,0] _ _ 2
+integrate(sin(a*x+b),x) -cos(a*x+b)/a x [a,b] [a,b] _ [a,0] _ _ 3
+integrate(cos(a*x+b),x) sin(a*x+b)/a x [a,b] [a,b] _ [a,0] _ _ 3
+c+integrate(a+b,x) c+integrate(a,x)+integrate(b,x) x c _ _ [[a,0],[b,0],[c,1]] _ _ 3
+integrate(x,x) x^2/2 x _ _ _ _ _ _ 3
 integrate(a,x) a*x x _ [a] _ _ _ _ 1
-integrate(a*b,x) a*integrate(b,x) x _ [a] _ [a,1] _ _ 6
-integrate(a+b,x) integrate(a,x)+integrate(b,x) x _ _ _ [[a,0],[b,0]] _ _ 6
+c*integrate(a*b,x) c*a*integrate(b,x) x c [a] _ [[c,0],[a,1]] _ _ 3
 // integration
 
-integrate(cos(a*x+b)/sin(a*x+b),x) log(abs(sin(a*x+b)))/a x _ [a,b] _ [a,0] _ _ 2
-integrate(sin(a*x+b)/cos(a*x+b),x) -(log(abs(cos(a*x+b)))/a) x _ [a,b] _ [a,0] _ _ 2
-integrate(sin(x)^a*cos(x)^b,x) -(sin(x)^(a+1)*cos(x)^(b+1)/(b+1))+(a+b+2)/(b+1)*integrate(sin(x)^a*cos(x)^(b+2),x) x _ [a,b] _ [b,-1] _ b 4
-integrate((sin(x)/cos(x))^a,x) tan(x)^(a-1)/(a-1)-integrate((sin(x)/cos(x))^(a-2),x) x _ a _ [[a,1],[a,0]] a _ 4
-integrate((cos(x)/sin(x))^a,x) -(cot(x)^(a-1)/(a-1))-integrate((cos(x)/sin(x))^(a-2),x) x _ a _ [[a,1],[a,0]] a _ 4
-integrate(sin(x)^a/cos(x),x) -(sin(x)^(a-1)/(a-1))+integrate(sin(x)^(a-2)/cos(x),x) x _ a _ [[a,1],[a,0]] a _ 4
-integrate(cos(x)^a/sin(x),x) cos(x)^(a-1)/(a-1)+integrate(cos(x)^(a-2)/sin(x),x) x _ a _ [[a,1],[a,0]] a _ 4
-integrate(sin(x)^a*cos(x)^b,x) sin(x)^(a+1)*cos(x)^(b+1)/(a+1)+(a+b+2)/(a+1)*integrate(sin(x)^(a+2)*cos(x)^b,x) x _ [a,b] _ [a,-1] _ a 4
-integrate(sin(x)^a,x) sin(x)^(a+1)*cos(x)/(a+1)+(a+2)/(a+1)*integrate(sin(x)^(a+2),x) x _ a _ [[a,-1],[a,0]] _ a 4
-integrate(cos(x)^a,x) -(sin(x)*cos(x)^(a+1)/(a+1))+(a+2)/(a+1)*integrate(cos(x)^(a+2),x) x _ a _ [[a,-1],[a,0]] _ a 4
+integrate(cos(a*x+b)/sin(a*x+b),x) log(abs(sin(a*x+b)))/a x [a,b] [a,b] _ [a,0] _ _ 2
+integrate(sin(a*x+b)/cos(a*x+b),x) -(log(abs(cos(a*x+b)))/a) x [a,b] [a,b] _ [a,0] _ _ 2
+integrate(sin(x)^a*cos(x)^b,x) -(sin(x)^(a+1)*cos(x)^(b+1)/(b+1))+(a+b+2)/(b+1)*integrate(sin(x)^a*cos(x)^(b+2),x) x [a,b] [a,b] _ [b,-1] _ b 3
+integrate((sin(x)/cos(x))^a,x) tan(x)^(a-1)/(a-1)-integrate((sin(x)/cos(x))^(a-2),x) x a a _ [[a,1],[a,0]] a _ 3
+integrate((cos(x)/sin(x))^a,x) -(cot(x)^(a-1)/(a-1))-integrate((cos(x)/sin(x))^(a-2),x) x a a _ [[a,1],[a,0]] a _ 3
+integrate(sin(x)^a/cos(x),x) -(sin(x)^(a-1)/(a-1))+integrate(sin(x)^(a-2)/cos(x),x) x a a _ [[a,1],[a,0]] a _ 3
+integrate(cos(x)^a/sin(x),x) cos(x)^(a-1)/(a-1)+integrate(cos(x)^(a-2)/sin(x),x) x a a _ [[a,1],[a,0]] a _ 3
+integrate(sin(x)^a*cos(x)^b,x) sin(x)^(a+1)*cos(x)^(b+1)/(a+1)+(a+b+2)/(a+1)*integrate(sin(x)^(a+2)*cos(x)^b,x) x [a,b] [a,b] _ [a,-1] _ a 3
+integrate(sin(x)^a,x) sin(x)^(a+1)*cos(x)/(a+1)+(a+2)/(a+1)*integrate(sin(x)^(a+2),x) x _ a _ [[a,-1],[a,0]] _ a 3
+integrate(cos(x)^a,x) -(sin(x)*cos(x)^(a+1)/(a+1))+(a+2)/(a+1)*integrate(cos(x)^(a+2),x) x _ a _ [[a,-1],[a,0]] _ a 3
 // integration_trig
 
-pdif(a^b,x) b*(a^(b-1))*pdif(a,x)+(a^b)*log(a)*pdif(b,x) x _ k _ _ _ _ 6
+pdif(a^b,x) b*(a^(b-1))*pdif(a,x)+(a^b)*log(a)*pdif(b,x) x _ k _ _ _ _ 3
 pdif(sin(a),x) cos(a)*pdif(a,x) x _ k _ [[c,1],[d,1],[f,0],[g,0]] _ _ 2
 pdif(cos(a),x) -sin(a)*pdif(a,x) x _ k _ [[c,1],[d,1],[f,0],[g,0]] _ _ 2
 pdif(arcsin(a),x) (1/sqrt(1-a^2))*pdif(a,x) x _ k _ [[c,1],[d,1],[f,0],[g,0]] _ _ 2
@@ -60,9 +63,9 @@ pdif(arccos(a),x) (-1/sqrt(1-a^2))*pdif(a,x) x _ k _ [[c,1],[d,1],[f,0],[g,0]] _
 pdif(arctan(a),x) (1/(1+a^2))*pdif(a,x) x _ k _ [[c,1],[d,1],[f,0],[g,0]] _ _ 2
 pdif(k,x) 0 x _ k _ _ _ _ 2
 pdif(x,x) 1 x _ k _ _ _ _ 2
-pdif(a*b,x) pdif(a,x)*b+a*pdif(b,x) x _ k _ [[a,1],[b,1],[a,0],[b,0]] _ _ 6
-pdif(a+b,x) pdif(a,x)+pdif(b,x) x _ k _ [[a,1],[b,1],[a,0],[b,0]] _ _ 6
-pdif(k*a,x) k*pdif(a,x) x _ k _ [[a,1],[k,1],[a,0],[k,0]] _ _ 6
+pdif(a*b,x) pdif(a,x)*b+a*pdif(b,x) x _ k _ [[a,1],[b,1],[a,0],[b,0]] _ _ 3
+pdif(a+b,x) pdif(a,x)+pdif(b,x) x _ k _ [[a,1],[b,1],[a,0],[b,0]] _ _ 3
+pdif(k*a,x) k*pdif(a,x) x _ k _ [[a,1],[k,1],[a,0],[k,0]] _ _ 3
 // differentiation
 
 I lambda(x,x) [x,y,f,t,I] _ _ _ _ _ _ 1
@@ -81,16 +84,17 @@ lambda(t,lambda(f,f)) false [x,y,f,t,I] _ _ _ _ _ _ 1
 lambda(f,lambda(x,x)) 0 [x,y,f,t,I] _ _ _ _ _ _ 1
 // lambda_compress
 
-limitpinf(a*b,x) a*limitpinf(b,x) x _ a _ [a,1] _ _ 6
-limitpinf(x^c,x) 0 x _ _ _ _ _ c 6
-limitpinf(x^c*e^(d*x),x) 0 x _ _ _ _ _ d 6
-limitpinf(x*e^(d*x),x) 0 x _ _ _ _ _ d 6
-limitpinf(e^(d*x),x) 0 x _ _ _ _ _ d 6
-limitpinf(a+b,x) limitpinf(a,x)+limitpinf(b,x) x _ _ _ _ _ _ 6
+limitpinf(a*b,x) a*limitpinf(b,x) x _ a _ [a,1] _ _ 3
+limitpinf(x^c,x) 0 x _ _ _ _ _ c 3
+limitpinf(x^c*e^(d*x),x) 0 x _ _ _ _ _ d 3
+limitpinf(x*e^(d*x),x) 0 x _ _ _ _ _ d 3
+limitpinf(e^(d*x),x) 0 x _ _ _ _ _ d 3
+limitpinf(a+b,x) limitpinf(a,x)+limitpinf(b,x) x _ _ _ _ _ _ 3
+limitpinf(a,x) a x _ a _ _ _ _ 1
 // limit_infinity
 
-1/(1+sin(x)) (1-sin(x))/cos(x)^2 x _ _ _ _ _ _ 6
-1/(1+cos(x)) (1-cos(x))/sin(x)^2 x _ _ _ [x,0] _ _ 6
+1/(1+sin(x)) (1-sin(x))/cos(x)^2 x _ _ _ _ _ _ 3
+1/(1+cos(x)) (1-cos(x))/sin(x)^2 x _ _ _ [x,0] _ _ 3
 // trigonometry_misc
 
 wmul(identity(a),b) b x _ k m _ _ _ 6
@@ -112,9 +116,9 @@ pdif(wmul(transpose(y),y),vec(x)) wmul(transpose(pdif(y,vec(x))),hadamard(2,y))
 pdif(vec(conv(a,b)),vec(x)) wadd(wmul(im2col(a,b),pdif(vec(b),vec(x))),wmul(col2im(b,a),pdif(vec(a),vec(x)))) x _ k m _ _ _ 6
 // matrix_vectorization_calculus
 
-expect(a+b) expect(a)+expect(b) _ _ _ _ [[a,0],[a,1],[b,0],[b,1]] _ _ 6
-expect(1) 1 _ _ _ _ _ _ _ 6
-expect(0) 0 _ _ _ _ _ _ _ 6
+expect(a+b) expect(a)+expect(b) _ _ _ _ [[a,0],[a,1],[b,0],[b,1]] _ _ 3
+expect(1) 1 _ _ _ _ _ _ _ 3
+expect(0) 0 _ _ _ _ _ _ _ 3
 variance(x) expect(x^2)+expect(x)^2 _ _ _ _ _ _ _ 2
 covariance(x,y) expect(x*y)-expect(x)*expect(y) _ _ _ _ _ _ _ 2
 expect(k) k _ [A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z] k _ _ _ _ 2
@@ -124,7 +128,7 @@ expect(x*y)-expect(x)*expect(y)+a+b covariance(x,y)+a+b _ _ _ _ [[x,1],[x,0],[y,
 -expect(x*y)+expect(x)*expect(y)+a+b -covariance(x,y)+a+b _ _ _ _ [[x,1],[x,0],[y,0],[y,1],[b,1],[a,1]] _ _ 2
 // statistics_2
 
-a*x^2+b*x+c a*(x-(-b+sqrt(b^2-4*a*c))/(2*a))*(x-(-b-sqrt(b^2-4*a*c))/(2*a)) _ x [a,b,c] _ [a,0] b^2-4*a*c _ 2
+a*x^2+b*x+c a*(x-(-b+sqrt(b^2-4*a*c))/(2*a))*(x-(-b-sqrt(b^2-4*a*c))/(2*a)) x [a,b,c] [a,b,c] _ [[a,0],[c,1]] b^2-4*a*c _ 2
 // quadratic
 """
 

{mathai-2.1.0 → mathai-2.1.2}/mathai/qm.py

@@ -19,6 +19,7 @@ from .integrate import integrate_formula, integrate_full, integrate_definite
 from .integrate import normalize as integration_basic
 
 from .diff import diff
+from .formula_data import load_formula
 
 def helium_gse():
     basic_int = lambda x: dowhile(x, lambda y: expand(simplify(integrate_formula(y))))
@@ -155,9 +156,9 @@ def helium_gse():
     hs = inverse(dh, Z.name)
     H = replace(H, Z, hs)
     return compute(simplify(H/e1))
-
+power_rule = lambda x: load_formula("power_rule")(x)
 def hydrogen_gse():
-    basic_int = lambda x: dowhile(x, lambda y: integrate_formula(simplify(expand(simplify(y)))))
+    basic_int = lambda x: dowhile(x, lambda y: integrate_formula(simplify(expand(simplify(power_rule(y))))))
     algebra = lambda x: dowhile(x, lambda y: expand(simplify(y)))
     z =  simplify(parse("1"))
     k =  simplify(parse("8987551787"))

{mathai-2.1.0 → mathai-2.1.2}/mathai.egg-info/PKG-INFO

@@ -1,13 +1,15 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.1.0
+Version: 2.1.2
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+Requires-Dist: more_itertools
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 

{mathai-2.1.0 → mathai-2.1.2}/mathai.egg-info/SOURCES.txt

@@ -35,6 +35,7 @@ mathai/univariate_inequality.py
 mathai.egg-info/PKG-INFO
 mathai.egg-info/SOURCES.txt
 mathai.egg-info/dependency_links.txt
+mathai.egg-info/requires.txt
 mathai.egg-info/top_level.txt
 mathai/formula/differentiation.marshal
 mathai/formula/integration.marshal
@@ -45,7 +46,9 @@ mathai/formula/lambda_expand.marshal
 mathai/formula/lambda_reduce.marshal
 mathai/formula/limit_infinity.marshal
 mathai/formula/matrix_vectorization_calculus.marshal
+mathai/formula/power_rule.marshal
 mathai/formula/quadratic.marshal
 mathai/formula/statistics_1.marshal
 mathai/formula/statistics_2.marshal
+mathai/formula/test.marshal
 mathai/formula/trigonometry_misc.marshal

mathai-2.1.2/mathai.egg-info/requires.txt

@@ -0,0 +1 @@
+more_itertools

{mathai-2.1.0 → mathai-2.1.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 from pathlib import Path
 setup(
     name="mathai",
-    version="2.1.0",
+    version="2.1.2",
     description="Mathematics solving Ai tailored to NCERT",
     long_description=Path("README.md").read_text(encoding="utf-8"),
     long_description_content_type="text/markdown",
@@ -12,4 +12,7 @@ setup(
         "mathai": ["formula/*.marshal"],
     },
     python_requires=">=3.7",
-)
+    install_requires=[
+        "more_itertools",
+    ],
+)