mathai 0.4.4__tar.gz → 0.4.6__tar.gz

{mathai-0.4.4 → mathai-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.4.4
+Version: 0.4.6
 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.4.4 → mathai-0.4.6}/mathai/__init__.py

@@ -1,3 +1,6 @@
+from .ode import diffsolve as ode_solve
+from .ode import diffsolve_sep as ode_shift_term
+
 from .expand import expand
 
 from .parser import parse
@@ -20,6 +23,8 @@ from .diff import diff
 
 from .factor import factor as factor1
 from .factor import factor2
+from .factor import rationalize_sqrt as rationalize
+from .factor import merge_sqrt
 from .factor import factorconst as factor0
 
 from .fraction import fraction

{mathai-0.4.4 → mathai-0.4.6}/mathai/base.py

@@ -253,6 +253,7 @@ def num_dem(equation):
         else:
             num = num*item
     return [num, tree_form("d_1")/den]
+
 def summation(lst):
     if lst == []:
         return tree_form("d_0")

{mathai-0.4.4 → mathai-0.4.6}/mathai/factor.py

@@ -69,6 +69,93 @@ def _factorconst(eq):
     if n != 1:
         return tree_form("d_"+str(n))*eq
     return TreeNode(eq.name, [factorconst(child) for child in eq.children])
+
+def _merge_sqrt(eq):
+    lst= []
+    eq2 = []
+    for child in factor_generation(eq):
+        if frac(child) is not None and frac(child).denominator==1:
+            if frac(child)>0:
+                eq2.append(child**2)
+            elif frac(child)!=-1:
+                eq2.append((-child)**2)
+                lst.append(tree_form("d_-1"))
+            else:
+                lst.append(tree_form("d_-1"))
+        elif child.name == "f_pow" and frac(child.children[1]) == Fraction(1,2):
+            eq2.append(child.children[0])
+        else:
+            lst.append(child)
+            
+    if len(eq2)>1:
+        if lst == []:
+            lst= [tree_form("d_1")]
+        return simplify(product(eq2)**(tree_form("d_2")**-1)*product(lst))
+    return TreeNode(eq.name, [_merge_sqrt(child) for child in eq.children])
+def sqrt_to_a_sqrt_b(n):
+    if n == 0:
+        return 0, 0
+    sign = 1
+    if n < 0:
+        sign = -1
+        m = -n
+    else:
+        m = n
+
+    a = 1
+    b = 1
+    p = 2
+    while p * p <= m:
+        exp = 0
+        while m % p == 0:
+            m //= p
+            exp += 1
+        if exp:
+            a *= p ** (exp // 2)
+            if exp % 2 == 1:
+                b *= p
+        p += 1 if p == 2 else 2
+
+    if m > 1:
+        b *= m
+
+    return sign * a, b
+def merge_sqrt(eq):
+    def helper(eq):
+        if eq.name == "f_pow" and frac(eq.children[1]) == Fraction(1,2):
+            if eq.children[0].name[:2] == "d_":
+                n = int(eq.children[0].name[2:])
+                a, b =sqrt_to_a_sqrt_b(n)
+                return tree_form("d_"+str(b))**(tree_form("d_2")**-1)*tree_form("d_"+str(a))
+        return TreeNode(eq.name, [helper(child) for child in eq.children])
+    return helper(_merge_sqrt(eq))
+def rationalize_sqrt(eq):
+    if eq.name== "f_pow" and frac(eq.children[1]) == Fraction(-1,2):
+        eq = eq.children[0]**(tree_form("d_2")**-1)/eq.children[0]
+    def term(eq):
+        if eq.name == "f_add":
+            output = []
+            for child in eq.children:
+                if any(child2.name == "f_pow" and frac(child2.children[1]) == Fraction(1,2) for child2 in factor_generation(child)):
+                    output.append(simplify(-child))
+                else:
+                    output.append(child)
+            return summation(output)
+        return None
+    n, d=num_dem(eq)
+    n,d=simplify(n), simplify(d)
+   
+    if d != 1:
+        t = term(d)
+        if t is not None and t!=1:
+            
+            n,d=simplify(expand(simplify(n*t))),simplify(expand(simplify(d*t)))
+            tmp= simplify(n/d)
+            
+            tmp = _merge_sqrt(tmp)
+            
+            return tmp
+    return TreeNode(eq.name, [rationalize_sqrt(child) for child in eq.children])
 def factorconst(eq):
     return simplify(_factorconst(eq))
 def factor_quad_formula_init():
@@ -77,6 +164,7 @@ def factor_quad_formula_init():
     formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
     expr = [[parse("A"), parse("1")], [parse("B"), parse("0"), parse("1")], [parse("C"), parse("0")]]
     return [formula_list, var, expr]
+
 def factor_quar_formula_init():
     var = ""
     formula_list = [(f"(A^4+B*A^2+C)", f"(A^2 + sqrt(2*sqrt(C) - B)*A + sqrt(C))*(A^2 - sqrt(2*sqrt(C) - B)*A + sqrt(C))")]

{mathai-0.4.4 → mathai-0.4.6}/mathai/integrate.py

@@ -367,7 +367,7 @@ def rm_const(equation):
     if equation.name == "f_ref":
         return equation
     eq2 = equation
-    if eq2.name == "f_integrate":
+    if eq2.name == "f_integrate" and contain(eq2.children[0], eq2.children[1]):
         equation = eq2.children[0]
         wrt = eq2.children[1]
         lst = factor_generation(equation)
@@ -407,4 +407,3 @@ def integrate_formula(equation):
                 
                 return out
     return TreeNode(eq2.name, [integrate_formula(child) for child in eq2.children])
-

mathai-0.4.6/mathai/ode.py

@@ -0,0 +1,124 @@
+from .factor import factor
+from .expand import expand
+from .base import *
+from .fraction import fraction
+from .simplify import simplify
+import copy
+
+def inversediff(lhs, rhs):
+    count = 4
+    while contain(rhs, tree_form("v_1")) or contain(lhs, tree_form("v_0")):
+        success = False
+        if rhs.name == "f_add":
+            for i in range(len(rhs.children)-1,-1,-1):
+                if not contain(rhs.children[i], tree_form("v_0")) or str_form(tree_form("v_1").fx("dif")) in [str_form(x) for x in factor_generation(rhs.children[i])]:
+                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
+                        success = True
+                    lhs = lhs - rhs.children[i]
+                    rhs.children.pop(i)
+        elif rhs.name == "f_mul":
+            for i in range(len(rhs.children)-1,-1,-1):
+                if not contain(rhs.children[i], tree_form("v_0")):
+                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
+                        success = True
+                    lhs = lhs / rhs.children[i]
+                    rhs.children.pop(i)
+        if len(rhs.children) == 1:
+            rhs = rhs.children[0]
+        rhs, lhs = copy.deepcopy([simplify(lhs), simplify(rhs)])
+        if rhs.name == "f_add":
+            for i in range(len(rhs.children)-1,-1,-1):
+                if not contain(rhs.children[i], tree_form("v_1")) or str_form(tree_form("v_0").fx("dif")) in [str_form(x) for x in factor_generation(rhs.children[i])]:
+                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
+                        success = True
+                    lhs = lhs - rhs.children[i]
+                    rhs.children.pop(i)
+        elif rhs.name == "f_mul":
+            for i in range(len(rhs.children)-1,-1,-1):
+                if not contain(rhs.children[i], tree_form("v_1")):
+                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
+                        success = True
+                    lhs = lhs / rhs.children[i]
+                    rhs.children.pop(i)
+        rhs, lhs = copy.deepcopy([simplify(lhs), simplify(rhs)])
+        if not success:
+            lhs, rhs = factor(lhs),factor(rhs)
+        count -= 1
+        if count == 0:
+            return simplify(e0(lhs-rhs))
+    return simplify(e0(lhs-rhs))
+
+intconst = ["v_"+str(i) for i in range(101,150)]
+def allocvar():
+    global intconst
+    return tree_form(intconst.pop(0))
+
+def epowersplit(eq):
+    if eq.name == "f_pow" and eq.children[1].name == "f_add":
+        return product([eq.children[0]**child for child in eq.children[1].children])
+    return TreeNode(eq.name, [epowersplit(child) for child in eq.children])
+def esolve(s):
+    if s.name == "f_add" and "f_log" in str_form(s):
+        return product([tree_form("s_e")**child for child in s.children]) - tree_form("d_1")
+    return TreeNode(s.name, [esolve(child) for child in s.children])
+def diffsolve_sep2(eq):
+    global tab
+    
+    s = []
+    eq = simplify(expand(eq))
+    eq = e1(eq)
+    
+    def vlor1(eq):
+        if contain(eq, tree_form("v_0")) and not contain(eq, tree_form("v_1")):
+            return True
+        if contain(eq, tree_form("v_1")) and not contain(eq, tree_form("v_0")):
+            return True
+        return False
+    if eq.name == "f_add" and all(vlor1(child) and [str_form(x) for x in factor_generation(copy.deepcopy(child))].count(str_form(tree_form(vlist(child)[0]).fx("dif")))==1 for child in eq.children):
+        for child in eq.children:
+            v = vlist(child)[0]
+            v2 = tree_form(v).fx("dif")
+            child = replace(child, v2, tree_form("d_1"))
+            child = simplify(child)
+            
+            
+            tmp6 = TreeNode("f_integrate", [child, tree_form(v)])
+            s.append(tmp6)
+            
+            if s[-1] is None:
+                return None
+        s.append(allocvar())
+    else:
+        return None
+    s = summation(s)
+    s = simplify(e0(s))
+    
+    return groupe(s)
+def e0(eq):
+    return TreeNode("f_eq", [eq, tree_form("d_0")])
+def e1(eq):
+    if eq.name == "f_eq":
+        eq = eq.children[0]
+    return eq
+def groupe(eq):
+    eq = esolve(eq)
+    eq = simplify(eq)
+    eq = fraction(eq)
+    eq = simplify(eq)
+    eq = epowersplit(eq)
+    return eq
+
+def diffsolve_sep(eq):
+    eq = epowersplit(eq)
+
+    eq = inversediff(tree_form("d_0"), eq.children[0].copy_tree())
+    return eq
+
+def diffsolve(eq):
+    orig = eq.copy_tree()
+
+    
+    eq = diffsolve_sep2(eq)
+    if eq is None:
+        return orig
+    return eq

{mathai-0.4.4 → mathai-0.4.6}/mathai/simplify.py

@@ -384,3 +384,4 @@ def simplify(eq):
     if error:
         return None
     return solve(eq)
+

{mathai-0.4.4 → mathai-0.4.6}/mathai/trig.py

@@ -82,7 +82,7 @@ def trig0(eq):
         if any(isneg(item) for item in lst):
             return -(eq.children[0]*-1).fx("sin")
         out=single_pi(lst)
-        if out is not None:
+        if out is not None and tuple(out) in trig_sin_table.keys():
             return trig_sin_table[tuple(out)]
     
     if eq.name == "f_cos":
@@ -211,35 +211,38 @@ def trig4(eq, numer=True):
     return TreeNode(eq.name, [trig4(child, False) if not numer or (eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]) < 0) else trig4(child, True) for child in eq.children])
 
 def trig2(eq):
-    if eq.name == "f_add":
-        for item in itertools.combinations(range(len(eq.children)), 2):
-            child1, child2 = eq.children[item[0]], eq.children[item[1]]
+    # Base case: if not an addition, recurse into children
+    if eq.name != "f_add":
+        return TreeNode(eq.name, [trig2(child) for child in eq.children])
+
+    # Try all pairs in the addition
+    for i, j in itertools.combinations(range(len(eq.children)), 2):
+        c1, c2 = eq.children[i], eq.children[j]
+
+        # Combine only sin/sin or cos/cos
+        if c1.name in ["f_sin", "f_cos"] and c2.name in ["f_sin", "f_cos"]:
+            A, B = c1.children[0], c2.children[0]
+            rest = [eq.children[k] for k in range(len(eq.children)) if k not in (i, j)]
+            rest_tree = summation(rest) if rest else tree_form("d_0")
 
-            # Check if both are sin or cos
-            if child1.name in ["f_sin", "f_cos"] and child2.name in ["f_sin", "f_cos"]:
-                a, b = child1.children[0], child2.children[0]
-                
-                # Compute the rest of the sum
-                rest = [eq.children[i] for i in range(len(eq.children)) if i not in item]
-                if len(rest) == 0:
-                    rest_tree = tree_form("d_0")
-                else:
-                    rest_tree = summation(rest)
+            two = tree_form("d_2")
 
-                # Now handle the sin/cos combination formula
-                if child1.name == "f_sin" and child2.name == "f_sin":
-                    # sin A + sin B = 2 sin((A+B)/2) cos((A-B)/2)
-                    two = tree_form("d_2")
-                    combined = two * ((a + b) / two).fx("sin") * ((a - b) / two).fx("cos")
-                elif child1.name == "f_cos" and child2.name == "f_cos":
-                    # cos A + cos B = 2 cos((A+B)/2) cos((A-B)/2)
-                    two = tree_form("d_2")
-                    combined = two * ((a + b) / two).fx("cos") * ((a - b) / two).fx("cos")
-                else:
-                    # sin A + cos B = sin A + cos B (leave unchanged, or implement formula if desired)
-                    continue  # skip for now, keep original
+            # sinA + sinB
+            if c1.name == "f_sin" and c2.name == "f_sin":
+                combined = two * ((A + B) / two).fx("sin") * ((A - B) / two).fx("cos")
 
-                return rest_tree + combined
+            # cosA + cosB
+            elif c1.name == "f_cos" and c2.name == "f_cos":
+                combined = two * ((A + B) / two).fx("cos") * ((A - B) / two).fx("cos")
 
-    # Recurse for other nodes
+            # sinA + cosB (leave unchanged)
+            else:
+                continue
+
+            new_expr = rest_tree + combined
+            # Re-run trig2 in case there are more sin/cos sums to simplify
+            return trig2(new_expr)
+
+    # If no sin/cos pairs found, just recurse on children
     return TreeNode(eq.name, [trig2(child) for child in eq.children])
+

{mathai-0.4.4 → mathai-0.4.6}/mathai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.4.4
+Version: 0.4.6
 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.4.4 → mathai-0.4.6}/mathai.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ mathai/inverse.py
 mathai/limit.py
 mathai/linear.py
 mathai/logic.py
+mathai/ode.py
 mathai/parser.py
 mathai/printeq.py
 mathai/simplify.py

{mathai-0.4.4 → mathai-0.4.6}/setup.py

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