mathai 0.7.2__tar.gz → 0.7.4__tar.gz

{mathai-0.7.2 → mathai-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.7.2
+Version: 0.7.4
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai4
 Requires-Python: >=3.7
@@ -96,7 +96,7 @@ print(equation)
 (cos(x)^2)+(sin(x)^2)
 ```
 
-### solve, simplify
+### simplify
 It simplifies and cleans up a given math equation.
 
 ```python

{mathai-0.7.2 → mathai-0.7.4}/README.md

@@ -81,7 +81,7 @@ print(equation)
 (cos(x)^2)+(sin(x)^2)
 ```
 
-### solve, simplify
+### simplify
 It simplifies and cleans up a given math equation.
 
 ```python

{mathai-0.7.2 → mathai-0.7.4}/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-0.7.2 → mathai-0.7.4}/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-0.7.4/mathai/expand.py

@@ -0,0 +1,75 @@
+from .base import *
+from .simplify import simplify
+import itertools
+
+def expand_nc(expr, label="f_mul"):
+    """
+    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)
+
+        # find first additive factor
+        for i, f in enumerate(factors):
+            if f.name == "f_add":
+                left  = factors[:i]
+                right = factors[i+1:]
+
+                terms = []
+                for term in f.children:
+                    new_factors = left + [term] + right
+                    terms.append(
+                        expand_nc(TreeNode(label, new_factors), label)
+                    )
+
+                return TreeNode("f_add", terms)
+
+        # no addition inside → return as-is
+        return TreeNode(label, factors)
+
+
+def expand(eq, over="*"):
+    over = {"@": "f_wmul", ".":"f_dot", "*":"f_mul"}[over]
+    return expand_nc(eq, over)

{mathai-0.7.2 → mathai-0.7.4}/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-0.7.2 → mathai-0.7.4}/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-0.7.2 → mathai-0.7.4}/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-0.7.4/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.2 → mathai-0.7.4}/mathai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.7.2
+Version: 0.7.4
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai4
 Requires-Python: >=3.7
@@ -96,7 +96,7 @@ print(equation)
 (cos(x)^2)+(sin(x)^2)
 ```
 
-### solve, simplify
+### simplify
 It simplifies and cleans up a given math equation.
 
 ```python

{mathai-0.7.2 → mathai-0.7.4}/mathai.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ mathai/parser.py
 mathai/parsetab.py
 mathai/printeq.py
 mathai/simplify.py
+mathai/statistics.py
 mathai/structure.py
 mathai/tool.py
 mathai/trig.py

{mathai-0.7.2 → mathai-0.7.4}/setup.py

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

mathai-0.7.2/mathai/expand.py

@@ -1,175 +0,0 @@
-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):
-    """
-    Performs exactly ONE distributive expansion.
-    Deepest-first (post-order).
-    """
-
-    # ---- 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:]
-
-                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
-
-            # === 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
-
-        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, []))
-
-# =====================================================
-# 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
-    return eq