mathai 0.7.1__py3-none-any.whl → 0.7.3__py3-none-any.whl

mathai/__init__.py

@@ -51,3 +51,5 @@ from .base import *
 from .tool import enclose_const
 from .tool import poly_simplify
 from .tool import longdiv
+
+from .statistics import expect

mathai/base.py

@@ -24,36 +24,9 @@ class TreeNode:
         children = copy.deepcopy(children)
         self.name = name
 
-        if name == "f_add" or (name == "f_mul" and TreeNode.matmul is None):
+        if name == "f_add" or name == "f_mul" or name == "f_dot":
             keyed = [(str_form(c), c) for c in children]
             self.children = [c for _, c in sorted(keyed)]
-
-        elif name == "f_mul" and TreeNode.matmul == False:
-            sortable = []
-            fixed = []
-            for c in children:
-                if not contains_list_or_neg(c):
-                    sortable.append(c)
-                else:
-                    fixed.append(c)
-                    
-            if len(sortable) > 1:
-                sortable = TreeNode("f_dmul", list(sorted(sortable, key=lambda x: str_form(x))))
-                sortable.name = "f_mul"
-                
-            elif len(sortable) == 1:
-                sortable = sortable[0]
-                
-            if isinstance(sortable, TreeNode):
-                fixed.append(sortable)
-            if len(fixed) > 1:
-                self.name = "f_wmul"
-            elif len(fixed) == 1:
-                self.name = fixed[0].name
-                fixed = fixed[0].children
-                
-                
-            self.children = fixed
         else:
             self.children = children
 
@@ -432,7 +405,7 @@ def string_equation_helper(equation_tree):
     s = "(" 
     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_wadd":"+", "f_wmul":"*", "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": "?"}
+    sign = {"f_not":"~", "f_wadd":"+", "f_wmul":"@", "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 = []
     k = None
     if equation_tree.name not in sign.keys():

mathai/expand.py

@@ -2,174 +2,77 @@ from .base import *
 from .simplify import simplify
 import itertools
 
-def eliminate_powers(node):
-    if not node.children:
-        return node
-
-    node.children = [eliminate_powers(c) for c in node.children]
-
-    if node.name == "f_pow":
-        base, exp = node.children
-        n = frac(exp)
-
-        # Only expand positive integer powers
-        if not (n and n.denominator == 1 and n.numerator > 1):
-            return node
-
-        n = n.numerator
-
-        # ---- Multinomial expansion ----
-        if base.name == "f_add":
-            terms = []
-            for combo in itertools.product(base.children, repeat=n):
-                prod = combo[0]
-                for c in combo[1:]:
-                    prod = prod * c
-                terms.append(prod)
-            return simplify(TreeNode("f_add", terms))
-
-        # ---- Fallback: simple power ----
-        return TreeNode("f_mul", [base] * n)
-
-    return node
-
-
-
-# =====================================================
-# Phase 2: Single distributive rewrite (DEEPEST FIRST)
-# =====================================================
-
-def expand_once(node):
+def expand_nc(expr, label="f_mul"):
     """
-    Performs exactly ONE distributive expansion.
-    Deepest-first (post-order).
+    Expand expression where:
+      - f_add is commutative
+      - label (@) is NON-commutative
     """
+    # --- base cases ---
+    if expr.name not in {"f_add", label, "f_pow"}:
+        return expr
+
+    # --- expand children first ---
+    expr.children = [expand_nc(c, label) for c in expr.children]
+
+    # ==========================================================
+    # POWER: (A + B)^n  only if n is positive integer
+    # ==========================================================
+    if expr.name == "f_pow":
+        base, exp = expr.children
+        n = frac(exp)
+        if n and n.denominator == 1 and n.numerator > 1:
+            factors = [base] * n.numerator
+            return expand_nc(TreeNode(label, factors), label)
+        return expr
+
+    # ==========================================================
+    # ADDITION (commutative)
+    # ==========================================================
+    if expr.name == "f_add":
+        out = []
+        for c in expr.children:
+            if c.name == "f_add":
+                out.extend(c.children)
+            else:
+                out.append(c)
+        return TreeNode("f_add", out)
+
+    # ==========================================================
+    # NON-COMMUTATIVE MULTIPLICATION (@)
+    # ==========================================================
+    if expr.name == label:
+        factors = []
+
+        # flatten only (NO reordering)
+        for c in expr.children:
+            if c.name == label:
+                factors.extend(c.children)
+            else:
+                factors.append(c)
 
-    # ---- recurse FIRST (this is the fix) ----
-    for i, c in enumerate(node.children):
-        new, changed = expand_once(c)
-        if changed:
-            node.children[i] = new
-            return node, True
-
-    # ---- now try expanding at this node ----
-    if node.name == "f_mul":
-        for i, child in enumerate(node.children):
-            if child.name == "f_add":
-                left = node.children[:i]
-                right = node.children[i+1:]
+        # find first additive factor
+        for i, f in enumerate(factors):
+            if f.name == "f_add":
+                left  = factors[:i]
+                right = factors[i+1:]
 
                 terms = []
-                for t in child.children:
-                    prod = t
-                    for r in right:
-                        prod = prod * r
-                    for l in reversed(left):
-                        prod = l * prod
-                    terms.append(prod)
-
-                return TreeNode("f_add", terms), True
-
-    return node, False
-
-def _expand2(equation):
-    """Iterative version of _expand without recursion."""
-    # Stack: (node, child_index, partially_processed_children)
-    stack = [(equation, 0, [])]
-
-    while stack:
-        node, child_index, processed_children = stack.pop()
-
-        # If all children are processed
-        if child_index >= len(node.children):
-            # Replace children with processed versions
-            node.children = processed_children
+                for term in f.children:
+                    new_factors = left + [term] + right
+                    terms.append(
+                        expand_nc(TreeNode(label, new_factors), label)
+                    )
 
-            # === Handle f_pow ===
-            if node.name == "f_pow":
-                n = frac(node.children[1])
-                if n is not None and n.denominator == 1 and n.numerator > 1:
-                    # Convert power to repeated multiplication
-                    power_children = [node.children[0] for _ in range(n.numerator)]
-                    new_node = TreeNode("f_mul", power_children)
-                    # Flatten tree
-                    node = flatten_tree(new_node)
-                    # Push it back for further processing
-                    stack.append((node, 0, []))
-                    continue
-
-            # === Handle f_mul ===
-            elif node.name == "f_mul":
-                # Separate lone children and bracket children
-                lone_children = tree_form("d_1")
-                bracket_children = []
-
-                # Iterate in reverse (like original)
-                for child in reversed(node.children):
-                    if child.name == "f_add":
-                        bracket_children.append(child)
-                    elif child.name == "f_pow" and child.children[0].name == "f_add":
-                        n = frac(child.children[1])
-                        if n is not None and n.denominator == 1 and n.numerator > 1:
-                            for _ in range(n.numerator):
-                                bracket_children.append(child.children[0])
-                        else:
-                            lone_children = lone_children * child
-                    else:
-                        lone_children = lone_children * child
-
-                lone_children = simplify(lone_children)
-
-                # Distribute bracket children over lone children iteratively
-                while bracket_children:
-                    tmp = tree_form("d_0")
-                    bracket = bracket_children.pop(0)
-                    for bc in bracket.children:
-                        if lone_children.name == "f_add":
-                            for lc in lone_children.children:
-                                tmp = tmp + bc * lc
-                        else:
-                            tmp = tmp + bc * lone_children
-                    # Simplify after each distribution
-                    lone_children = flatten_tree(simplify(tmp))
-
-                node = lone_children
-
-            # === Return node to parent ===
-            if stack:
-                parent, idx, parent_children = stack.pop()
-                parent_children.append(node)
-                stack.append((parent, idx + 1, parent_children))
-            else:
-                # Root node fully expanded
-                return node
+                return TreeNode("f_add", terms)
 
-        else:
-            # Push current node back for next child
-            stack.append((node, child_index, processed_children))
-            # Push the child to process next
-            child = flatten_tree(node.children[child_index])
-            stack.append((child, 0, []))
+        # no addition inside → return as-is
+        return TreeNode(label, factors)
 
-# =====================================================
-# Phase 3: Global fixed-point driver
-# =====================================================
 
 def expand(eq):
-    orig = TreeNode.matmul
-    if TreeNode.matmul is None:
-        return _expand2(eq)
-    eq = simplify(eq)
-    if TreeNode.matmul is not None:
-        TreeNode.matmul = True
-        eq = tree_form(str_form(eq).replace("f_wmul", "f_mul"))
-        eq = flatten_tree(eq)
-    eq = eliminate_powers(eq)
-    while True:        
-        eq = flatten_tree(eq)        
-        eq, changed = expand_once(eq)
-        if not changed:
-            break
-    eq =simplify(eq)
-    TreeNode.matmul = orig
+    s = str_form(eq)
+    for item in ["f_mul", "f_wmul", "f_dot", "f_cross"]:
+        if item in s:
+            eq = expand_nc(eq, item)
     return eq

mathai/matrix.py

@@ -219,10 +219,7 @@ def flat(eq):
 def use(eq):
     return TreeNode(eq.name, [use(child) for child in eq.children])
 def _matrix_solve(eq):
-    if TreeNode.matmul == True:
-        TreeNode.matmul = False
-        eq = dowhile(eq, lambda x: fold_wmul(use(flat(x))))
-        TreeNode.matmul = True
+    eq = dowhile(eq, lambda x: fold_wmul(flat(x)))
     return eq
 def matrix_solve(eq):
     return _matrix_solve(eq)

mathai/parser.py

@@ -37,7 +37,8 @@ grammar = """
            | arithmetic "-" term   -> sub
            | term
 
-?term: term "*" power  -> wmul
+?term: term "*" power  -> mul
+     | term "@" power  -> wmul
      | term "/" power  -> div
      | term "." power  -> dot
      | power
@@ -59,7 +60,7 @@ grammar = """
      | ESCAPED_STRING      -> string
      | CAPITAL_ID          -> matrix
 
-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"
+FUNC_NAME: "midpoint" | "ref" | "expect" | "covariance" | "variance" | "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 +131,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 + ["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","wmul","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", "cross", "wmul","integrate","dif","pow","div","log","abs"] else "d_" + tree_node.name,
             [fxchange(child) for child in tree_node.children]
         )
 
@@ -155,10 +156,4 @@ def parse(equation, funclist=None):
     
     tree_node = rfx(tree_node)
     tree_node = flatten_tree(tree_node)
-    if TreeNode.matmul == True:
-        TreeNode.matmul = False
-        tree_node = use(tree_form(str_form(tree_node).replace("f_w","f_")))
-        TreeNode.matmul = True
-    else:
-        tree_node = tree_form(str_form(tree_node).replace("f_w","f_"))
     return tree_node

mathai/simplify.py

@@ -507,17 +507,10 @@ def solve3(eq):
 def simplify(eq, basic=True):
     if eq is None:
         return None
-    orig = TreeNode.matmul
-    if TreeNode.matmul == True:
-        TreeNode.matmul = False
-    if TreeNode.matmul == False:
-        eq = use(tree_form(str_form(eq).replace("f_w","f_")))
-        
     if eq.name == "f_and" or eq.name == "f_not" or eq.name == "f_or":
         new_children = []
         for child in eq.children:
             new_children.append(simplify(child))
-        TreeNode.matmul = orig
         return TreeNode(eq.name, new_children)
     if eq.name[2:] in "gt ge lt le eq".split(" "):
         denom = eq.name != "f_eq"
@@ -530,11 +523,9 @@ def simplify(eq, basic=True):
             value2 = {"ge":"le", "le":"ge", "gt":"lt", "lt":"gt", "eq":"eq"}[value2]
         value2 = "f_"+value2
         out = TreeNode(value2, [tmp, tree_form("d_0")])
-        TreeNode.matmul = orig
         return out
     eq = flatten_tree(eq)
     if basic:
         eq = convert_to_basic(eq)
     eq = solve3(eq)
-    TreeNode.matmul = orig
     return eq

mathai/statistics.py

@@ -0,0 +1,23 @@
+from .base import *
+from .simplify import simplify
+
+def expect(eq):
+    if eq.name == "f_expect":
+        if eq.children[0].name == "f_add":
+            eq = summation([item.fx("expect") for item in eq.children[0].children])
+    if eq.name == "f_expect":
+        out = []
+        keep = []
+        for child in eq.children:
+            if "v_-" in str_form(child) and child.name != "f_expect":
+                keep.append(child)
+            else:
+                out.append(child)
+        eq = simplify(product(out)*product(keep).fx("expect"))
+    if eq.name == "f_variance":
+        term = eq.children[0]
+        eq = (term**2).fx("expect") + term.fx("expect")**2
+    if eq.name == "f_covariance":
+        x, y = eq.children
+        eq = (x*y).fx("expect") - x.fx("expect")*y.fx("expect")
+    return TreeNode(eq.name, [expect(child) for child in eq.children])

{mathai-0.7.1.dist-info → mathai-0.7.3.dist-info}/METADATA

@@ -1,13 +1,11 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.7.1
+Version: 0.7.3
 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
@@ -98,7 +96,7 @@ print(equation)
 (cos(x)^2)+(sin(x)^2)
 ```
 
-### solve, simplify
+### simplify
 It simplifies and cleans up a given math equation.
 
 ```python
@@ -117,7 +115,7 @@ printeq(equation)
 
 ### Demonstrations
 
-#### Example Demonstration 1
+#### Example Demonstration 1 (absolute value inequalities)
 ```python
 from mathai import *
 question_list_from_lecture = [
@@ -157,7 +155,7 @@ for item in question_list_from_lecture:
 (-inf,-(7/3))
 ```
 
-#### Example Demonstration 2
+#### Example Demonstration 2 (trigonometry)
 ```python
 from mathai import *
 def nested_func(eq_node):
@@ -182,7 +180,7 @@ true
 true
 ```
 
-#### Example Demonstration 3
+#### Example Demonstration 3 (integration)
 ```python
 from mathai import *
 
@@ -237,3 +235,59 @@ cos(cos(x))
 -((e^-(x^2))/2)
 -(((8*sin((2*x)))-(12*x)-sin((4*x)))/32)
 ```
+
+#### Example Demonstration 4 (derivation of hydrogen atom's ground state energy in electron volts using the variational principle in quantum physics)
+```python
+from mathai import *;
+def auto_integration(eq):
+    for _ in range(3):
+        eq=dowhile(integrate_subs(eq),lambda x:integrate_summation(integrate_const(integrate_formula(simplify(expand(x))))));
+        out=integrate_clean(copy.deepcopy(eq));
+        if "f_integrate" not in str_form(out):return dowhile(out,lambda x:simplify(fraction(x)));
+        eq=integrate_byparts(eq);
+    return eq;
+z,k,m,e1,hbar=map(lambda s:simplify(parse(s)),["1","8987551787","9109383701*10^(-40)","1602176634*10^(-28)","1054571817*10^(-43)"]);
+pi,euler,r=tree_form("s_pi"),tree_form("s_e"),parse("r");a0=hbar**2/(k*e1**2*m);psi=((z**3/(pi*a0**3)).fx("sqrt"))*euler**(-(z/a0)*r);
+laplace_psi=diff(r**2*diff(psi,r.name),r.name)/r**2;V=-(k*z*e1**2)/r;Hpsi=-hbar**2/(2*m)*laplace_psi+V*psi;
+norm=lambda f:simplify(
+    limit3(limit2(expand(TreeNode("f_limitpinf",[auto_integration(TreeNode("f_integrate",[f*parse("4")*pi*r**2,r])),r]))))
+    -limit1(TreeNode("f_limit",[auto_integration(TreeNode("f_integrate",[f*parse("4")*pi*r**2,r])),r]))
+);
+print(compute(norm(psi*Hpsi)/(norm(psi**2)*e1)));
+```
+#### Output
+
+```
+-13.605693122882867
+```
+
+#### Example Demonstration 5 (boolean algebra)
+```python
+from mathai import *
+print(logic_n(simplify(parse("~(p<->q)<->(~p<->q)"))))
+print(logic_n(simplify(parse("(p->q)<->(~q->~p)"))))
+```
+#### Output
+
+```
+true
+true
+```
+
+#### Example Demonstration 6 (limits)
+```python
+from mathai import *
+limits = ["(e^(tan(x)) - 1 - tan(x)) / x^2", "sin(x)/x", "(1-cos(x))/x^2", "(sin(x)-x)/sin(x)^3"]
+for q in limits:
+    q = fraction(simplify(TreeNode("f_limit",[parse(q),parse("x")])))
+    q = limit1(q)
+    print(q)
+```
+#### Output
+
+```
+1/2
+1
+1/2
+-(1/6)
+```

{mathai-0.7.1.dist-info → mathai-0.7.3.dist-info}/RECORD

@@ -1,10 +1,10 @@
-mathai/__init__.py,sha256=Mv0vNdV-FHKS6MzAsnHsE0eBtSkCUq0nc9tUgCWxbFo,1541
+mathai/__init__.py,sha256=elVGU1vjxbvzY3CQ8M5kzj5i6o8YyCsdb2vw-kSxTN0,1575
 mathai/apart.py,sha256=VSS3khE9PNuxiRvdU5JDl4IN-KJBSIFjwR17pkhviXI,4197
-mathai/base.py,sha256=hRiJWS94asWl-t11eGrVCEhZqIub0T-8S_Eqmlun6mI,15819
+mathai/base.py,sha256=XNmXWADG7mA4AeyFbCUsjBvUzDnw8AzWscX0Cc3GjvA,14854
 mathai/bivariate_inequality.py,sha256=Da-A1kqVynR0tNOlEI7GSTf5T2vNkcF4etL9-EoyPJg,11415
 mathai/console.py,sha256=Sn58iwYE79MLEh67s8X3q6vZjw6g7f9XM1T8_dBBR2o,3048
 mathai/diff.py,sha256=RSTwlfeddvYXUDShCeRdcPjsmAS8Vf5OkYJAaUBPaiM,3060
-mathai/expand.py,sha256=r2Ha6graDLgLOlx3ox4egUvJD5L_-4_n-FQs2wyWVKg,6284
+mathai/expand.py,sha256=AEX-inLztL6i7VWSu0Zw1z9OVwhomrnoqGrQiDuoPQE,2502
 mathai/factor.py,sha256=3wcmZOGUqMlLj4v2DA14ZLqEQ7khavOi7PjZJU6VX40,12494
 mathai/fraction.py,sha256=88xvRpDGfFi8tbe1QIyejdSP91HcErrN4VS2MxzbhrY,4392
 mathai/integrate.py,sha256=C_lqYgQN4UiriCb_LDkpwtKx7XJhp_K8T9skCkxWqas,17208
@@ -12,17 +12,18 @@ mathai/inverse.py,sha256=ya7P8WjzfaAL3UXL7xqOh5GaIsXLDZ-F6lZFy3IEgaQ,2931
 mathai/limit.py,sha256=9F8i9UZh2xb-V8A5Sd1gdhDf9c2RFgpE1GdNn9MvbWI,5703
 mathai/linear.py,sha256=viGlPU8BPrjLWHlyNUvnfPHNH5d4ZBImiQMdyXaKGg0,5702
 mathai/logic.py,sha256=Ndz4Fd6aNCmzFlqoPyyIpSmV_BXmYHsurePjLyZJoNc,9809
-mathai/matrix.py,sha256=sIusSmZN0Y6k4TovI5L6Hepls9i7FPRjA3CZIU4X4_w,7276
+mathai/matrix.py,sha256=MFe6tUL4a3jYuP13fXWGwER_34AbqfoOK5kHwVHfsKk,7169
 mathai/ode.py,sha256=zxxTXAOpt7oSsfpgI4vHsCWKXevmM96ZOBZWWs-vj8Y,4801
-mathai/parser.py,sha256=3cBl7DhqL275gqXszET5zC85O9v3XKxRPc2EaOigAns,7302
+mathai/parser.py,sha256=FcjOTM_2-YFqPNS9EyZfo76pa4CedDJCbcs8wOXc_uU,7130
 mathai/parsetab.py,sha256=TL-4jvRM_Tx6ipwet8CFJc2DkjR4tGsbrGF_r4IC8xI,9651
 mathai/printeq.py,sha256=4UgLJo-vV_YlVw_3QUQY_jQMHrFnG-ZKAyVZsd7yD6o,1450
-mathai/simplify.py,sha256=VsUw89U3FqSpD3mMUGM0pr0dZ__MDQOBD8maaB7MDBY,19973
+mathai/simplify.py,sha256=bCtYyLyc3pY04hta-MU62ii5-O4zUwGHjs1Q4WBYEvY,19680
+mathai/statistics.py,sha256=ifmaXFzRc6vIgPFWP-9EDfZZYmmMGw-WEKhoQZUaHXo,884
 mathai/structure.py,sha256=wrU7kqphSN7CqaVffyHHXD2-3t5My_Z_TtYFoUe_lTU,4099
 mathai/tool.py,sha256=ozcXTXLbKUnyPM9r9kz9M43YA2CBcWezcqLZfEs8rpc,6051
 mathai/trig.py,sha256=fnBbfiopcQzFg4ya1BoO5M0X_aCBnse2bjnKh1juw4I,11223
 mathai/univariate_inequality.py,sha256=LPFdWgC1y5zBwnsy1wwZxj-yP_SbqFDhCmTTzhuwoiY,16469
-mathai-0.7.1.dist-info/METADATA,sha256=n_NIEmTCflCFZpdeleCh5NQaV2lrITXa4es41rV4aSk,5887
-mathai-0.7.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mathai-0.7.1.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
-mathai-0.7.1.dist-info/RECORD,,
+mathai-0.7.3.dist-info/METADATA,sha256=O-xwE15PJRC2oY1xe7-JWyBlDlvcIcCwSxlcDNwdk5s,7735
+mathai-0.7.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mathai-0.7.3.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
+mathai-0.7.3.dist-info/RECORD,,