mathai 2.3.4__tar.gz → 2.3.6__tar.gz

{mathai-2.3.4 → mathai-2.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.3.4
+Version: 2.3.6
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai
 Requires-Python: >=3.7

{mathai-2.3.4 → mathai-2.3.6}/mathai/__init__.py

@@ -5,6 +5,8 @@ from .pde import solve_pde
 
 from .qm import hydrogen_gse, helium_gse, power_rule
 
+from .graphics import draw_graphics_from_solution, solve_graphics, solve_graphics_string
+
 from .lambda_calculus import lambda_expand, lambda_compress, lambda_reduce
 
 from .electronic import Edge, CircuitGraph, find_resistance
@@ -15,8 +17,6 @@ from .test import test
 
 from .decision import god, trig7
 
-from .graphics import solve_graphics, solve_graphics_string
-
 from .expand import expand
 
 from .ml import NeuralNetwork, diff_matrix_matrix
@@ -30,12 +30,10 @@ from .formula_applier import formula_applier, formula_list_applier
 
 from .integrate import integrate_subs_main as integrate_subs
 from .integrate import byparts as integrate_byparts
-from .integrate import sqint as integrate_fraction
-from .integrate import conv_int
+from .integrate import integrate_fraction
 from .integrate import solve_integrate as integrate_clean
-from .integrate import integrate_formula, integrate_trig_formula, integrate_qm_formula, integrate_full, integrate_definite
+from .integrate import integrate_formula, integrate_trig_formula, integrate_full, def_integrate_formula
 from .integrate import normalize as integration_basic
-from .integrate import normalize_qm as integration_qm_basic
 
 from .diff import diff, diff2
 
@@ -52,7 +50,7 @@ from .inverse import inverse, inverse2
 from .logic import logic0, set_sub, truth_gen, solve_logically
 from .apart import apart, apart2
 
-from .limit import limit1, limit2, limit0, limit3, limit4, solve_inf
+from .limit import limit1, limit2, limit0, limit3, limit4, solve_inf, limit5
 
 from .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt, prepare, eq2range, range2eq2, simple_wavycurvy
 

{mathai-2.3.4 → mathai-2.3.6}/mathai/decision.py

@@ -1,6 +1,6 @@
 import math
 from .inverse import inverse, inverse2
-from .integrate import integrate_full
+from .integrate import integrate_full, def_integrate_formula
 from .ode import diffsolve as ode_solve
 from .parser import parse
 from .simplify import simplify, log0
@@ -328,7 +328,10 @@ def god(string):
             eq = simplify(ode_solve(simplify(eq)))
             log.append(eq)
         if "f_integrate" in str_form(eq):
+            eq = def_integrate_formula(eq)
             eq = integrate_full(eq)
+            eq = limit5(eq)
+            eq = limit1(eq)
         eq = simplify(expand(simplify(eq)))
         print(f"=> {eq}")
         print()

mathai-2.3.6/mathai/diff.py

@@ -0,0 +1,179 @@
+from .simplify import simplify
+from .base import *
+from .parser import parse
+from .formula_applier import formula_list_applier
+
+diff2_s = """pdif(e^a,x) e^a*pdif(a,x) [] x _ _ _
+pdif(a^b,x) b*(a^(b-1))*pdif(a,x)+(a^b)*log(a)*pdif(b,x) [] x _ _ _
+pdif(sin(a),x) cos(a)*pdif(a,x) [] x _ _ _
+pdif(cos(a),x) -sin(a)*pdif(a,x) [] x _ _ _
+pdif(arcsin(a),x) (1/sqrt(1-a^2))*pdif(a,x) [] x _ _ _
+pdif(arccos(a),x) (-1/sqrt(1-a^2))*pdif(a,x) [] x _ _ _
+pdif(arctan(a),x) (1/(1+a^2))*pdif(a,x) [] x _ _ _
+pdif(k,x) 0 [] x k _ _
+pdif(x,x) 1 [] x _ _ _
+pdif(product(a,b),x) pdif(a,x)*b+a*pdif(b,x) [] x _ _ _
+pdif(sum(a,b),x) pdif(a,x)+pdif(b,x) [] x _ _ _
+pdif(product(k,a),x) k*pdif(a,x) [] x k _ _"""
+
+diff2 = lambda x: formula_list_applier(x, diff2_s)
+'''
+def diff(equation, var=None):
+    var = var if var else "v_0"
+    out = diff2(simplify(TreeNode("f_pdif", [equation, tree_form(var)])))
+    return out
+'''
+def diff(equation, var="v_0"):
+    def diffeq_iterative(root_eq):
+        stack = [(root_eq, False)]
+        results = {}
+        while stack:
+            eq, processed = stack.pop()
+            if eq in results:
+                continue
+            if not processed:
+                eq_simplified = simplify(eq)
+                if "v_" not in str_form(eq_simplified):
+                    results[eq] = tree_form("d_0")
+                    continue
+                stack.append((eq, True))
+                if eq.name in ("f_add", "f_mul"):
+                    for child in eq.children:
+                        if child not in results:
+                            stack.append((child, False))
+                elif eq.name in ("f_abs", "f_tan", "f_log", "f_arcsin", "f_arccos", "f_arctan", "f_sin", "f_cos"):
+                    child = eq.children[0]
+                    if child not in results:
+                        stack.append((child, False))
+                elif eq.name == "f_pow":
+                    for child in eq.children:
+                        if child not in results:
+                            stack.append((child, False))
+            else:
+                if "v_" not in str_form(eq):
+                    results[eq] = tree_form("d_0")
+                    continue
+                if eq.name == "f_add":
+                    add_res = tree_form("d_0")
+                    for child in eq.children:
+                        add_res = add_res + results.get(child, tree_form("d_0"))
+                    results[eq] = add_res
+                elif eq.name == "f_abs":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    results[eq] = du * u / eq
+                elif eq.name == "f_pow" and eq.children[0].name == "s_e":
+                    u = eq.children[1]
+                    du = results.get(u, tree_form("d_0"))
+                    results[eq] = du * eq
+                elif eq.name == "f_tan":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    cos_u = u.fx("cos")
+                    results[eq] = du / (cos_u * cos_u)
+                elif eq.name == "f_log":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    results[eq] = du * (tree_form("d_1") / u)
+                elif eq.name == "f_arcsin":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    one = tree_form("d_1")
+                    half = tree_form("d_2") ** tree_form("d_-1")
+                    results[eq] = du / ((one - u * u) ** half)
+                elif eq.name == "f_arccos":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    one = tree_form("d_1")
+                    half = tree_form("d_2") ** tree_form("d_-1")
+                    results[eq] = tree_form("d_-1") * du / ((one - u * u) ** half)
+                elif eq.name == "f_arctan":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    results[eq] = du / (tree_form("d_1") + u * u)
+                elif eq.name == "f_pow" and "v_" in str_form(eq.children[1]):
+                    u, v = eq.children
+                    du = results.get(u, tree_form("d_0"))
+                    dv = results.get(v, tree_form("d_0"))
+                    term1 = (v / u) * du
+                    term2 = u.fx("log") * dv
+                    results[eq] = (u ** v) * (term1 + term2)
+                elif eq.name == "f_mul":
+                    add_res = tree_form("d_0")
+                    n_children = len(eq.children)
+                    for i in range(n_children):
+                        target_child = eq.children[i]
+                        d_target = results.get(target_child, tree_form("d_0"))
+                        other_terms = [eq.children[j] for j in range(n_children) if j != i]
+                        if len(other_terms) == 1:
+                            other_prod = other_terms[0]
+                        else:
+                            other_prod = TreeNode("f_mul", other_terms)
+                        add_res = add_res + (d_target * other_prod)
+                    results[eq] = add_res
+                elif eq.name == "f_sin":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    results[eq] = du * u.fx("cos")
+                elif eq.name == "f_cos":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    results[eq] = tree_form("d_-1") * du * u.fx("sin")
+                elif eq.name[:2] == "v_":
+                    results[eq] = TreeNode("f_dif", [eq])
+                elif eq.name == "f_pow" and "v_" not in str_form(eq.children[1]):
+                    base, power = eq.children
+                    dbase = results.get(base, tree_form("d_0"))
+                    power_minus_1 = power - tree_form("d_1")
+                    results[eq] = power * (base ** power_minus_1) * dbase
+                else:
+                    results[eq] = TreeNode("f_dif", [eq, tree_form(var)])
+        return results.get(root_eq, tree_form("d_0"))
+    def helper2_iterative(root_eq, target_var):
+        stack = [(root_eq, False)]
+        results = {}
+        while stack:
+            eq, processed = stack.pop()
+            if eq in results:
+                continue
+            if not processed:
+                stack.append((eq, True))
+                for child in eq.children:
+                    if child not in results:
+                        stack.append((child, False))
+            else:
+                if eq.name == "f_dif":
+                    if eq.children[0].name == target_var:
+                        results[eq] = tree_form("d_1")
+                    elif not contain(eq.children[0], target_var):
+                        results[eq] = tree_form("d_0")
+                    else:
+                        results[eq] = eq
+                else:
+                    new_children = [results.get(child, child) for child in eq.children]
+                    results[eq] = TreeNode(eq.name, new_children)
+        return results.get(root_eq, root_eq)
+    def calc_iterative(root_eq):
+        stack = [(root_eq, False)]
+        results = {}
+        while stack:
+            eq, processed = stack.pop()
+            if eq in results:
+                continue
+            if not processed:
+                stack.append((eq, True))
+                for child in eq.children:
+                    if child not in results:
+                        stack.append((child, False))
+            else:
+                if eq.name == "f_dif":
+                    results[eq] = diffeq_iterative(eq.children[0])
+                else:
+                    new_children = [results.get(child, child) for child in eq.children]
+                    results[eq] = TreeNode(eq.name, new_children)
+        return results.get(root_eq, root_eq)
+    if var is None:
+        return simplify(calc_iterative(equation))
+    equation = diffeq_iterative(equation)
+    equation = helper2_iterative(equation, var)
+    return simplify(equation)

{mathai-2.3.4 → mathai-2.3.6}/mathai/formula_applier.py

@@ -253,8 +253,10 @@ def _match_struct_bind_core(eq, f, binding, const_1_vars, ignore_set, resolved_i
         for item in vlist(eq):
             out = extract_polynomial_coefficients(eq_plain, item, degree)
             if out is not None:
-                out = out[::-1][1:]
-                if out[0] != 0:
+                out = out[::-1]
+                while out[0] == 0:
+                    out.pop(0)
+                if len(out) == degree:                    
                     local_binding = binding.copy()
                     for i in range(1, len(f.children)):
                         local_binding[f.children[i].name] = out[i - 1]

{mathai-2.3.4 → mathai-2.3.6}/mathai/graphics.py

@@ -46,5 +46,56 @@ def solve_graphics(Ax, Ay, Az, Bx, By, Bz, BAx, BAy, BAz, phi, theta, fvl, tvl,
     return final_solution
 def solve_graphics_string(s):
     s_parsed = [None if item == "None" else parse(item) for item in s.split()]
-    for key, item in solve_graphics(*s_parsed).items():
+    solution = solve_graphics(*s_parsed)
+    for key, item in solution.items():
         print(f"{key} : {item}")
+    return solution
+def draw_graphics_from_solution(solution):
+    import matplotlib.pyplot as plt
+    import numpy as np
+    def get_val(key):
+        if key in solution:
+            val = solution[key]
+            try:
+                return float(compute(val))
+            except Exception:
+                try:
+                    return float(str(val))
+                except Exception:
+                    return 0.0
+        return 0.0
+    Ax = get_val('Ax')
+    Ay = get_val('Ay')
+    Az = get_val('Az')
+    Bx = get_val('Bx')
+    By = get_val('By')
+    Bz = get_val('Bz')
+    fa_x, fa_y = Az, Ay
+    fb_x, fb_y = Bz, By
+    ta_x, ta_y = Az, -Ax
+    tb_x, tb_y = Bz, -Bx
+    fig, ax = plt.subplots(figsize=(9, 7))
+    x_min = min(fa_x, fb_x, ta_x, tb_x) - 25
+    x_max = max(fa_x, fb_x, ta_x, tb_x) + 25
+    ax.axhline(0, color='black', linewidth=1.5, label='Reference Axis')
+    ax.plot([fa_x, fb_x], [fa_y, fb_y], 'r-', linewidth=2, label="Front View (a' b')")
+    ax.plot(fa_x, fa_y, 'ro', markersize=5)
+    ax.plot(fb_x, fb_y, 'ro', markersize=5)
+    ax.text(fa_x - 3, fa_y + 3, "a'", fontsize=11, color='red', fontweight='bold')
+    ax.text(fb_x + 3, fb_y + 3, "b'", fontsize=11, color='red', fontweight='bold')
+    ax.plot([ta_x, tb_x], [ta_y, tb_y], 'b-', linewidth=2, label="Top View (a b)")
+    ax.plot(ta_x, ta_y, 'bo', markersize=5)
+    ax.plot(tb_x, tb_y, 'bo', markersize=5)
+    ax.text(ta_x - 3, ta_y - 8, "a", fontsize=11, color='blue', fontweight='bold')
+    ax.text(tb_x + 3, tb_y - 8, "b", fontsize=11, color='blue', fontweight='bold')
+    ax.plot([fa_x, ta_x], [fa_y, ta_y], 'k--', alpha=0.5)
+    ax.plot([fb_x, tb_x], [fb_y, tb_y], 'k--', alpha=0.5)
+    ax.set_aspect('equal', adjustable='datalim')
+    ax.grid(True, linestyle=':', alpha=0.6)
+    ax.set_xlabel('Coordinate Axis (Az / Bz)', fontsize=10)
+    ax.set_ylabel('Height / Depth', fontsize=10)
+    ax.set_title('Engineering Drawing: Projections of a Line', fontsize=13, fontweight='bold', pad=15)
+    ax.legend(loc='upper right', framealpha=0.9)
+    plt.tight_layout()
+    plt.savefig('line_projections.png', dpi=300)
+    plt.show()

{mathai-2.3.4 → mathai-2.3.6}/mathai/integrate.py

@@ -217,106 +217,7 @@ def integrate_subs_main_helper(equation):
     return equation
 def integrate_subs_main(equation):
     return transform_dfs(equation, integrate_subs_main_helper)
-def _sqint(equation):
-    def sgn(eq):
-        if compute(eq) <0:
-            return tree_form("d_-1"), tree_form("d_-1")*eq
-        return tree_form("d_1"), eq
-    eq2 = equation
-    if eq2.name == "f_integrate":
-        equation = eq2.children[0]
-        var = eq2.children[1]
-        one = tree_form("d_1")
-        two = tree_form("d_2")
-        four = tree_form("d_4")
-        three = tree_form("d_3")
-        root = tree_form("d_2")**-1
-        zero = tree_form("d_0")
-        n, d = num_dem(equation)
-        n, d = simplify(n), simplify(d)
-        term = [simplify(x) for x in factor_generation(d)]
-        const = product([item for item in term if "v_" not in str_form(item)])
-        term = [item for item in term if "v_" in str_form(item)]
-        mode = False
-        if all(item.name == "f_pow" and simplify(item.children[1]-root) == zero for item in term):
-            d = simplify(expand(const**two*product([item.children[0] for item in term])))
-        else:
-            mode = True
-            if any(item.name == "f_pow" and simplify(item.children[1]-root) == zero for item in term):
-                return None
-        if vlist(equation) == []:
-            return None
-        v = vlist(equation)[0]
-        x = tree_form(v)
-        np = poly(n, v)
-        dp = poly(d, v)
-        if np is None or dp is None:
-            return None
-        if len(np) == 1 and len(dp) == 3:
-            k, a, b, c = np+dp
-            if a == zero:
-                return None
-            s1, s2 = sgn(a)
-            const = (four*a*c - b**two)/(four*a)
-            t1, t2 = sgn(const)
-            la = s2**root
-            lb = b*s2**root/(two*a)
-            if mode:
-                if s1 == one:
-                    if t1 == one:
-                        if simplify(t2**root) == tree_form("d_0"):
-                            return None
-                        return k*((la*x+lb)/t2**root).fx("arctan")/(la * t2**root)
-                    else:
-                        return None
-                else:
-                    if t1 == one:
-                        return None
-                    else:
-                        _, t2 = sgn(-const)
-                        return -k*((la*x+lb)/t2**root).fx("arctan")/(la * t2**root)
-            if s1 == one:
-                if t1 == one:
-                    return simplify(k*(la*x + lb + ((la*x + lb)**two + t2)**root).fx("abs").fx("log")/la)
-                else:
-                    return simplify(k*(la*x + lb + ((la*x + lb)**two - t2)**root).fx("abs").fx("log")/la)
-            else:
-                if t1 == one:
-                    return k*((la*x + lb)/t2**root).fx("arcsin")/la
-                else:
-                    return None
-        if len(np) == 2 and len(dp) == 3:
-            p, q, a, b, c = np+dp
-            if a == zero:
-                return None
-            A = p/(two*a)
-            B = q - A*b
-            t = a*x**two + b*x + c
-            if not mode:
-                tmp = _sqint(TreeNode("f_integrate", [simplify(one/t**root), var]))
-                if tmp is None:
-                    tmp = TreeNode("f_integrate", [simplify(one/t**root), var])
-                return A*two*t**root + tmp*B
-            else:
-                tmp = _sqint(TreeNode("f_integrate", [simplify(one/t), var]))
-                if tmp is None:
-                    tmp = TreeNode("f_integrate", [simplify(one/t), var])
-                return A*t.fx("abs").fx("log") + tmp*B
-        equation = eq2
-    coll = TreeNode(equation.name, [])
-    for child in equation.children:
-        out = _sqint(child)
-        if out is None:
-            coll.children.append(child)
-        else:
-            coll.children.append(out)
-    return coll
-def sqint(eq):
-    eq = _sqint(eq)
-    out = simplify(eq)
-    if out is None:
-        return eq
-    return out
+
 def byparts(eq):
     if eq.name == "f_ref":
         return eq
@@ -353,6 +254,21 @@ def byparts(eq):
         eq = eq2
     return TreeNode(eq.name, [byparts(child) for child in eq.children])
 
+integrate_fraction_s = """integrate(1/sqrt(poly(x,a,b,c)),x) 1/sqrt(a)*log(abs(sqrt(a)*x+b/(2*sqrt(a))+sqrt((sqrt(a)*x+b/(2*sqrt(a)))^2+(4*a*c-b^2)/(4*a)))) [] x [a,b,c] [a,4*a*c-b^2] _ [[a,0],[b^2-4*a*c,0]]
+integrate(1/sqrt(poly(x,a,b,c)),x) 1/sqrt(a)*log(abs(sqrt(a)*x+b/(2*sqrt(a))+sqrt((sqrt(a)*x+b/(2*sqrt(a)))^2-(b^2-4*a*c)/(4*a)))) [] x [a,b,c] [a,b^2-4*a*c] _ [[a,0],[4*a*c-b^2,0]]
+integrate(1/sqrt(poly(x,a,b,c)),x) 1/sqrt(-a)*arcsin((sqrt(-a)*x-b/(2*sqrt(-a)))/sqrt((4*a*c-b^2)/(4*a))) [] x [a,b,c] [4*a*c-b^2] a [[a,0],[b^2-4*a*c,0]]
+integrate(1/poly(x,a,b,c),x) 1/(sqrt(a)*sqrt((4*a*c-b^2)/(4*a)))*arctan((sqrt(a)*x+b/(2*sqrt(a)))/sqrt((4*a*c-b^2)/(4*a))) [] x [a,b,c] [a,4*a*c-b^2] _ [[a,0],[b^2-4*a*c,0]]
+integrate(1/poly(x,a,b,c),x) -1/(sqrt(-a)*sqrt((b^2-4*a*c)/(-4*a)))*arctan((sqrt(-a)*x-b/(2*sqrt(-a)))/sqrt((b^2-4*a*c)/(-4*a))) [] x [a,b,c] _ [a,b^2-4*a*c] [[a,0],[4*a*c-b^2,0]]
+integrate(poly(x,p,q)/sqrt(poly(x,a,b,c)),x) (p/a)*sqrt(a*x^2+b*x+c)+(q-p*b/(2*a))*integrate(1/sqrt(a*x^2+b*x+c),x) [] x [p,q,a,b,c] _ _ _ [[a,0]]
+integrate(poly(x,p,q)/poly(x,a,b,c),x) (p/(2*a))*log(abs(a*x^2+b*x+c))+(q-p*b/(2*a))*integrate(1/(a*x^2+b*x+c),x) [] x [p,q,a,b,c] _ _ _ [[a,0]]"""
+integrate_fraction = lambda x: formula_list_applier(x, integrate_fraction_s)
+
+def_integrate_formula_s = """integrate(abs(poly(x,a,b)),x,m,n) ((a*n+b)*abs(a*n+b)-(a*m+b)*abs(a*m+b))/(2*a) [] x [a,b] _ _
+integrate(abs(sin(x)),x) 2*floor(x/pi)+1-cos(x-pi*floor(x/pi)) [] x _ _ _
+integrate(u,x,a,inf) limitpinf(integrate(u,x),x)-limit(integrate(u,x),x,a) [] x a _ _ _
+integrate(u,x,a,b) limit(integrate(u,x),x,b)-limit(integrate(u,x),x,a) [] x [a,b] _ _ _"""
+def_integrate_formula = lambda x: formula_list_applier(x, def_integrate_formula_s)
+
 integrate_formula_s = """
 integrate(x^2*e^(poly(x,a,b)),x) ((x^2/a)-(2*x/(a^2))+(2/(a^3)))*e^(a*x+b) [] x [a,b] _ _
 integrate(x*e^(poly(x,a,b)),x) ((x/a)-(1/(a^2)))*e^(a*x+b) [] x [a,b] _ _
@@ -386,166 +302,6 @@ integrate(sin(x)^a,x) sin(x)^(a+1)*cos(x)/(a+1)+(a+2)/(a+1)*integrate(sin(x)^(a+
 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 [[a,-1]]"""
 integrate_trig_formula = lambda x: formula_list_applier(x, integrate_trig_s)
 
-def shorten(eq):
-    if eq.name.startswith("d_"):
-        return tree_form("d_0")
-    return TreeNode(eq.name, [shorten(child) for child in eq.children])
-
-def integrate_qm_formula(equation):
-    out = transform_dfs(equation, integrate_formula_h, [True])
-    return out
-def has_nested_trig(node, seen_trig=False):
-    if not isinstance(node, TreeNode):
-        return False
-    trig = {
-        "f_sin", "f_cos", "f_tan",
-        "f_sec", "f_cosec", "f_cot"
-    }
-    is_trig = node.name in trig
-    if is_trig and seen_trig:
-        return True
-    seen_trig = seen_trig or is_trig
-    children = getattr(node, "args", None) or getattr(node, "children", None) or []
-    for c in children:
-        if has_nested_trig(c, seen_trig):
-            return True
-    return False
-def has_nested_trig(node, seen_trig=False):
-    if not isinstance(node, TreeNode):
-        return False
-    trig = {
-        "f_sin", "f_cos", "f_tan",
-        "f_sec", "f_cosec", "f_cot"
-    }
-    is_trig = node.name in trig
-    if is_trig and seen_trig:
-        return True
-    seen_trig = seen_trig or is_trig
-    children = getattr(node, "args", None) or getattr(node, "children", None) or []
-    for c in children:
-        if has_nested_trig(c, seen_trig):
-            return True
-    return False
-def sin_range(eq, n, wrt):
-    a = tree_form(f"d_{n}")*parse("pi/2")
-    b = tree_form(f"d_{n+1}")*parse("pi/2")
-    return eq2range(wavycurvy(simplify(TreeNode("f_lt", [a,eq]) & TreeNode("f_lt", [eq,b])), wrt)), tree_form("d_1") if (n // 2)%2 ==0 else tree_form("d_-1")
-def def_int_h(eq, start, end, wrt, root):
-    if eq.name == "f_abs" and eq.children[0].name == "f_sin":
-        lst = []
-        f = Range()
-        f.r = [False, start, True, end, False]
-        a = math.floor(compute(start)/compute(parse("pi/2")))
-        b = math.floor(compute(end)/compute(parse("pi/2")))+1
-        for i in range(a,b+1):
-            inq, sgn = sin_range(eq.children[0].children[0], i, wrt)
-            inq = eq2range(wavycurvy(range2eq2(f&inq))).fix()
-            if len(inq.r) != 5:
-                continue
-            eqn = TreeNode("f_integrate", [eq.children[0]*sgn, wrt])
-            eqn2 = TreeNode("f_subs", [eqn, wrt, inq.r[3]]) - TreeNode("f_subs", [eqn, wrt, inq.r[1]])
-            lst.append(eqn2)
-        return simplify(summation(lst))
-    elif eq.name == "f_max" and len(eq.children) == 2:
-        if len(vlist(eq)) == 2:
-            if eq.children[0].name.startswith("v_") and eq.children[1].name.startswith("v_"):
-                if start != tree_form("d_0") or end != tree_form("s_inf"):
-                    return None
-                var = tree_form(list(set(vlist(eq))-set([wrt.name]))[0])
-                a = replace(copy.deepcopy(root), eq, var)
-                b = replace(copy.deepcopy(root), eq, wrt)
-                return TreeNode("f_integrate", [a.children[0],wrt,start,var])+TreeNode("f_integrate", [b.children[0],wrt,var, end])
-    elif eq.name == "f_abs":
-        if len(vlist(eq)) == 1:
-            lst = []
-            f = TreeNode("f_gt", [eq.children[0], tree_form("d_0")])
-            f = simplify(f)
-            g = TreeNode("f_lt", [eq.children[0], tree_form("d_0")])
-            g = simplify(g)
-            h = Range()
-            h.r = [False, start, True, end, False]
-            f = eq2range(wavycurvy(f, wrt))
-            f = (f & h).fix()
-            g = eq2range(wavycurvy(g, wrt))
-            g = (g & h).fix()
-            if f.r[0] or f.r[-1] or g.r[0] or g.r[-1]:
-                return None
-            for i in range(2):
-                for j in range(len([f,g][i].r)):
-                    if [f,g][i].r[j] == True:
-                        eqn = TreeNode("f_integrate", [eq.children[0]*[tree_form("d_1"), tree_form("d_-1")][i], wrt])
-                        eqn2 = TreeNode("f_subs", [eqn, wrt, [f,g][i].r[j+1]]) - TreeNode("f_subs", [eqn, wrt, [f,g][i].r[j-1]])
-                        lst.append(eqn2)
-            return simplify(summation(lst))
-        elif len(vlist(eq)) > 1:
-            out = inverse(copy.deepcopy(eq.children[0]), wrt.name, True)
-            if out is None:
-                return None
-            eqn, sign = out
-            test = copy.deepcopy(eqn)
-            pos = True
-            neg = True
-            for item in vlist(eq.children[0]):
-                out = diff(eq.children[0],item)
-                if frac(out) is None:
-                    pos = False
-                    neg = False
-                elif frac(out) > 0:
-                    neg = False
-                elif frac(out) < 0:
-                    pos = False
-                test = replace(test, tree_form(item), tree_form("d_0"))
-            a = None
-            if simplify(test-start) != 0:
-                return None
-            if pos or neg:
-                if sign:
-                    return TreeNode("f_integrate", [replace(copy.deepcopy(root), eq, eq.children[0]).children[0],wrt,start,end])
-                else:
-                    return TreeNode("f_integrate", [replace(copy.deepcopy(root), eq, -eq.children[0]).children[0],wrt,start,end])
-            a = replace(copy.deepcopy(root), eq, -eq.children[0])
-            b = replace(copy.deepcopy(root), eq, eq.children[0])
-            if not sign:
-                a, b = b, a
-            out = TreeNode("f_integrate", [a.children[0],wrt,start, eqn])+TreeNode("f_integrate", [b.children[0],wrt,eqn, end])
-            return out
-    return None
-def conv_int2(eq, wrt, start, end):
-    lst = []
-    for item in [start, end]:
-        if item == tree_form("s_inf"):
-            lst.append(TreeNode("f_limitpinf", [eq, wrt]))
-        else:
-            lst.append(TreeNode("f_limit", [replace(copy.deepcopy(eq), wrt, wrt+item), wrt]))
-    return lst[1]-lst[0]
-def conv_int_h(eq):
-    if (eq.name == "f_integrate" and len(eq.children) == 4):
-        lst = []
-        for item in [eq.children[2], eq.children[3]]:
-            if item == tree_form("s_inf"):
-                lst.append(TreeNode("f_limitpinf", [TreeNode("f_integrate", copy.deepcopy(eq.children[:2])), eq.children[1]]))
-            else:
-                lst.append(TreeNode("f_limit", [TreeNode("f_integrate", [replace(copy.deepcopy(eq.children[0]),eq.children[1],eq.children[1]+item),\
-                                                                         eq.children[1]]), eq.children[1]]))
-        return lst[1]-lst[0]
-    return eq
-def conv_int(eq):
-    return transform_dfs(eq, conv_int_h, [])
-def def_int(eq, start, end, wrt, root):
-    out = def_int_h(eq, start, end, wrt, root)
-    if out is not None:
-        return out
-    for child in eq.children:
-        out = def_int(child, start, end, wrt, root)
-        if out is not None:
-            return out
-    return None
-def integrate_definite(eq):
-    if eq.name == "f_integrate" and len(eq.children) == 4:
-        out = def_int(eq.children[0], eq.children[2], eq.children[3], eq.children[1], eq)
-        if out is not None:
-            return out
-    return TreeNode(eq.name, [integrate_definite(child) for child in eq.children])
 def normalize(x, f=True):
     x = simplify(x)
     x = factor2(x)
@@ -553,24 +309,13 @@ def normalize(x, f=True):
         x = dowhile(x, lambda y: fraction(simplify(integrate_formula(y))))
     else:
         x = dowhile(x, lambda y: simplify(integrate_formula(y)))
-    out = sqint(x)
-    if out is not None:
-        x = out
-    return x
-def normalize_qm(x, f=True):
-    x = simplify(x)
-    x = integrate_summation(x)
-    x = factor2(x)
-    if f:
-        x = dowhile(x, lambda y: fraction(simplify(integrate_qm_formula(rm_const(integrate_summation(y))))))
-    else:
-        x = dowhile(x, lambda y: simplify(integrate_qm_formula(rm_const(integrate_summation(y)))))
-    out = sqint(x)
+    out = integrate_fraction(x)
     if out is not None:
         x = out
     return x
+
 def integrate_full(root):
-    root = integrate_definite(trig0(root))
+    root = trig0(root)
     def is_solved(x):
         x = solve_integrate(x)
         return "f_integrate" not in str_form(x)

{mathai-2.3.4 → mathai-2.3.6}/mathai/qm.py

@@ -12,10 +12,9 @@ from .inverse import inverse
 
 from .integrate import integrate_subs_main as integrate_subs
 from .integrate import byparts as integrate_byparts
-from .integrate import sqint as integrate_fraction
-from .integrate import conv_int
+from .integrate import integrate_fraction
 from .integrate import solve_integrate as integrate_clean
-from .integrate import integrate_formula, integrate_full, integrate_definite
+from .integrate import integrate_formula, integrate_full
 from .integrate import normalize as integration_basic
 
 from .diff import diff

{mathai-2.3.4 → mathai-2.3.6}/mathai/simplify.py

@@ -356,6 +356,14 @@ def other_node(root):
                         if child != tree_form("d_1")
                     ])
                     continue
+            if eq.name == "f_abs":
+                out = frac(eq.children[0])
+                if out is not None:
+                    if out >= 0:
+                        result_map[eq] = eq.children[0]
+                    else:
+                        result_map[eq] = -eq.children[0]
+                    continue
             if eq.name == "f_sgn":
                 out = frac(eq.children[0])
                 if out is not None:

{mathai-2.3.4 → mathai-2.3.6}/mathai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.3.4
+Version: 2.3.6
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai
 Requires-Python: >=3.7

{mathai-2.3.4 → mathai-2.3.6}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="mathai",
-    version="2.3.4",
+    version="2.3.6",
     description="Mathematics solving Ai tailored to NCERT",
     long_description=Path("README.md").read_text(encoding="utf-8"),
     long_description_content_type="text/markdown",

mathai-2.3.4/mathai/diff.py

@@ -1,24 +0,0 @@
-from .simplify import simplify
-from .base import *
-from .parser import parse
-from .formula_applier import formula_list_applier
-
-diff2_s = """pdif(e^a,x) e^a*pdif(a,x) [] x _ _ _
-pdif(a^b,x) b*(a^(b-1))*pdif(a,x)+(a^b)*log(a)*pdif(b,x) [] x _ _ _
-pdif(sin(a),x) cos(a)*pdif(a,x) [] x _ _ _
-pdif(cos(a),x) -sin(a)*pdif(a,x) [] x _ _ _
-pdif(arcsin(a),x) (1/sqrt(1-a^2))*pdif(a,x) [] x _ _ _
-pdif(arccos(a),x) (-1/sqrt(1-a^2))*pdif(a,x) [] x _ _ _
-pdif(arctan(a),x) (1/(1+a^2))*pdif(a,x) [] x _ _ _
-pdif(k,x) 0 [] x k _ _
-pdif(x,x) 1 [] x _ _ _
-pdif(product(a,b),x) pdif(a,x)*b+a*pdif(b,x) [] x _ _ _
-pdif(sum(a,b),x) pdif(a,x)+pdif(b,x) [] x _ _ _
-pdif(product(k,a),x) k*pdif(a,x) [] x k _ _"""
-
-diff2 = lambda x: formula_list_applier(x, diff2_s)
-
-def diff(equation, var=None):
-    var = var if var else "v_0"
-    out = diff2(simplify(TreeNode("f_pdif", [equation, tree_form(var)])))
-    return out