mathai 2.5.0__tar.gz → 2.5.2__tar.gz

{mathai-2.5.0 → mathai-2.5.2}/PKG-INFO

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

{mathai-2.5.0 → mathai-2.5.2}/mathai/__init__.py

@@ -44,11 +44,7 @@ from .integrate import normalize as integration_basic
 
 from .diff import diff, diff2
 
-from .factor import factor as factor1
-from .factor import factor2, take_common
-from .factor import rationalize_sqrt as rationalize
-from .factor import merge_sqrt
-from .factor import factorconst as factor0
+from .factor import factor0, factor1, factor2
 
 from .fraction import fraction, fraction0
 

{mathai-2.5.0 → mathai-2.5.2}/mathai/benchmark.py

@@ -200,7 +200,7 @@ def execute_parallel(tree, equation, terminal_condition=None):
 
 
 def god2(string, parallel=False):
-    tree = strategy_tree(load_sequences("ncert_data"))
+    tree = strategy_tree(load_sequences("ncert_data_optimized"))
     if parallel:
         out = execute_parallel(tree, simplify(parse(string)), _no_integrate_left)
     else:

{mathai-2.5.0 → mathai-2.5.2}/mathai/decision.py

@@ -11,7 +11,7 @@ from .univariate_inequality import simple_wavycurvy, wavycurvy, prepare, absolut
 from .fraction import fraction
 from .expand import expand
 from .logic import logic0, set_sub, truth_gen, solve_logically
-from .factor import factor2, factor
+from .factor import factor2, factor1, factor0
 from .limit import limit1, limit5
 from .linear import linear_solve
 from .matrix import matrix_solve, matrix_formula

mathai-2.5.2/mathai/factor.py

@@ -0,0 +1,66 @@
+
+import math
+
+from .base import *  # tree_form, TreeNode, str_form, factor_generation, product, summation, partitions ...
+from .simplify import simplify
+from .expand import expand  # noqa: F401
+from .formula_compiler import formula_list_compiler
+
+# Kept so that `from .factor import *` in other modules keeps working.
+from .parser import parse  # noqa: F401
+from .simplify import convert_to_basic  # noqa: F401
+from .tool import poly  # noqa: F401
+from .fraction import fraction
+
+
+factor2 = formula_list_compiler("poly(x,a,b,c) a*(x-(-b+sqrt(b^2-4*a*c))/(2*a))*(x-(-b-sqrt(b^2-4*a*c))/(2*a)) [] _ _ b^2-4*a*c _")
+factor1_s = """x^2-y^2 (x+y)*(x-y) [] _ _ _ _
+x^3-y^3 (x-y)*(x^2+x*y+y^2) [] _ _ _ _
+x^3+y^3 (x+y)*(x^2-x*y+y^2) [] _ _ _ _
+x*y+a*y+x+a (x+a)*(y+1) [[a,1]] _ _ _ _
+a*b+a*c a*(b+c) [[b,1]] _ _ _ _
+a*b*c+a*b*d a*b*(c+d) [] _ _ _ _
+a*x+b*x (a+b)*x [] _ _ _ _
+a*x+a*y a*(x+y) [] _ _ _ _
+a*c+a*d+b*c+b*d (a+b)*(c+d) [] _ _ _ _
+x^2+2*a*x+a^2 (x+a)^2 [] _ _ _ _
+x^2-2*a*x+a^2 (x-a)^2 [] _ _ _ _
+a*b*c+a*d a*(b*c+d) [] _ _ _ _"""
+factor1 = formula_list_compiler(factor1_s)
+
+def _coeff(term):
+    """Integer coefficient of a term (1 if none)."""
+    for item in factor_generation(term):
+        if item.name.startswith("d_"):
+            try:
+                return int(item.name[2:])
+            except ValueError:
+                return 1
+    return 1
+
+
+def _hcf(numbers):
+    """gcd of the coefficients; negative only if every coefficient is negative."""
+    g = 0
+    for x in numbers:
+        g = math.gcd(g, x)
+    if g == 0:
+        return 1
+    if numbers and all(x < 0 for x in numbers):
+        return -g
+    return g
+
+
+def _factorconst(eq):
+    if not eq.children:
+        return eq
+    if eq.name == "f_add":
+        n = _hcf([_coeff(child) for child in eq.children])
+        if n != 1:
+            const = tree_form("d_" + str(n))
+            return const * TreeNode(eq.name, [child / const for child in eq.children])
+    return TreeNode(eq.name, [_factorconst(child) for child in eq.children])
+
+
+def factor0(eq):
+    return simplify(_factorconst(eq))

{mathai-2.5.0 → mathai-2.5.2}/mathai/integrate.py

@@ -1,6 +1,4 @@
-from .factor import factor2
-from .factor import factorconst as factor0
-from .factor import factor as factor1
+from .factor import factor2, factor1, factor0
 from .parser import parse
 import itertools
 from .diff import diff
@@ -289,14 +287,14 @@ def byparts(eq):
             return TreeNode("f_try", output)
         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(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] [4*a*c-b^2] a [[a,0],[b^2-4*a*c,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 = formula_list_compiler(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] _ _

{mathai-2.5.0 → mathai-2.5.2}/mathai/linear.py

@@ -6,7 +6,7 @@ from .simplify import simplify
 from .fraction import fraction
 from .expand import expand
 from .base import *
-from .factor import factorconst
+
 from .tool import poly
 
 def ss(eq):

{mathai-2.5.0 → mathai-2.5.2}/mathai/logic.py

@@ -4,7 +4,7 @@ from .base import *
 from .fraction import fraction
 from .simplify import simplify
 from .expand import expand
-from .factor import factorconst
+
 def set_sub(eq):
   if eq.name == "f_sub":
     return eq.children[0] & eq.children[1].fx("not")

mathai-2.5.2/mathai/ode.py

@@ -0,0 +1,302 @@
+from collections import Counter
+
+from .base import *  # tree_form, TreeNode, contain, replace, str_form, factor_generation, product, summation ...
+from .factor import factor1, factor2   # factor1 = formula-list compiler (takes ONE expression, not a list)
+from .fraction import fraction
+from .simplify import simplify
+from .inverse import inverse
+from .parser import parse
+
+# --------------------------------------------------------------------------- #
+# Constants (built once)
+# --------------------------------------------------------------------------- #
+ZERO = tree_form("d_0")
+ONE = tree_form("d_1")
+TWO = tree_form("d_2")
+NEG_ONE = tree_form("d_-1")
+E = tree_form("s_e")
+I = tree_form("s_i")
+V0 = tree_form("v_0")
+V1 = tree_form("v_1")
+V2 = tree_form("v_2")
+V = (V0, V1)
+DIF0 = V0.fx("dif")
+DIF1 = V1.fx("dif")
+INV_DIF0 = DIF0 ** -1
+INV_DIF1 = DIF1 ** -1
+
+_MAX_DEPTH = 8     # bound on the shift/factor rewriting loop in inversediff
+
+
+# --------------------------------------------------------------------------- #
+# Small helpers
+# --------------------------------------------------------------------------- #
+def _has_name(node, name):
+    return node.name == name or any(_has_name(c, name) for c in node.children)
+
+
+def _terms(eq):
+    return list(eq.children) if eq.name == "f_add" else [eq]
+
+
+def _expr(eq):
+    """The 'expression = 0' side of an equation (or the expression itself)."""
+    if eq.name == "f_eq":
+        lhs, rhs = eq.children
+        return lhs if rhs == ZERO else lhs - rhs
+    return eq
+
+
+def allocvar():
+    return tree_form("v_101")
+
+
+def clist(x):
+    return list(x.elements())
+
+
+def e0(eq):
+    return TreeNode("f_eq", [eq, ZERO])
+
+
+def e1(eq):
+    return eq.children[0] if eq.name == "f_eq" else eq
+
+
+# --------------------------------------------------------------------------- #
+# Separation of variables
+# --------------------------------------------------------------------------- #
+def rev(eq):
+    factors = factor_generation(eq)
+    if INV_DIF0 in factors or INV_DIF1 in factors:
+        return False
+    return all(rev(child) for child in eq.children)
+
+
+def check(eq):
+    """False if some single factor mixes x and y."""
+    return not any(contain(f, V0) and contain(f, V1) for f in factor_generation(eq))
+
+
+def shift(lhs, rhs):
+    """Rearrange  lhs + rhs = 0  into  A(x) = B(y)-style sides; returns [new_lhs, new_rhs]."""
+    if isinstance(lhs, list):
+        lhs = simplify(summation(lhs))
+    if isinstance(rhs, list):
+        rhs = simplify(summation(rhs))
+    rhs = simplify(-rhs)
+    sides = [factor_generation(lhs), factor_generation(rhs)]
+    moved = [[], []]          # moved[k] = factors that must be divided out of side k
+    for i in (0, 1):
+        stay = []
+        for f in sides[i]:
+            if contain(f, V[1 - i]) and not contain(f, V[i]):
+                moved[1 - i].append(f)
+            else:
+                stay.append(f)
+        sides[i] = stay
+    output = [simplify(product(sides[i]) * product(moved[i]) ** NEG_ONE) for i in (0, 1)]
+    if any(_has_name(item, "f_dif") for item in output) and DIF0 not in factor_generation(output[0]):
+        output = [ONE / item for item in output]
+    return output
+
+
+def inversediff(lhs, rhs, old=None):
+    if lhs is None or rhs is None:
+        return None
+    old = [] if old is None else old
+    if len(old) > _MAX_DEPTH:
+        return None
+
+    eq = factor1(simplify(lhs - rhs))
+    if eq in old:                       # already seen -> rewriting is looping
+        return None
+
+    const, xonly, yonly, mixed = [], [], [], []
+    for item in _terms(eq):
+        cx, cy = contain(item, V0), contain(item, V1)
+        if cx and cy:
+            mixed.append(item)
+        elif cx:
+            xonly.append(item)
+        elif cy:
+            yonly.append(item)
+        else:
+            const.append(item)
+    (yonly if yonly else xonly).extend(const)
+
+    if not mixed:
+        return simplify(lhs - rhs)      # already separated (unfactored form, so terms stay iterable)
+
+    m = factor1(summation(mixed))       # factor1 takes an expression, not a list
+    mixed = _terms(m)
+    nxt = old + [eq]
+
+    if xonly and yonly:
+        out = inversediff(*shift(mixed + xonly, yonly), nxt)
+        if out is None:
+            out = inversediff(*shift(xonly, factor1(summation(mixed + yonly))), nxt)
+        return out
+    if yonly:
+        if m.name == "f_add":
+            return None
+        return inversediff(*shift(m, yonly), nxt)
+    if xonly:
+        if m.name == "f_add":
+            return None
+        return inversediff(*shift(xonly, m), nxt)
+    if len(mixed) == 2:
+        return inversediff(*shift(*mixed), nxt)
+    return None
+
+
+def epowersplit(eq):
+    if not eq.children:
+        return 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 not s.children:
+        return s
+    if s.name == "f_add" and _has_name(s, "f_log"):
+        return product([E ** child for child in s.children]) - ONE
+    return TreeNode(s.name, [esolve(child) for child in s.children])
+
+
+def groupe(eq):
+    eq = simplify(esolve(eq))
+    eq = simplify(fraction(eq))
+    return epowersplit(eq)
+
+
+def diffsolve_sep(eq):
+    expr = e1(epowersplit(eq))
+    return inversediff(ZERO, expr.copy_tree())
+
+
+def diffsolve_sep2(eq):
+    """Integrate a separated form  f(x)dx + g(y)dy  term by term."""
+    if eq is None:
+        return None
+    parts = [allocvar()]
+    for item in _terms(eq):
+        factors = factor_generation(simplify(item))
+        rest = product([k for k in factors if k.name != "f_dif"])
+        if DIF0 in factors:
+            parts.append(TreeNode("f_integrate", [rest, V0]))
+        elif DIF1 in factors:
+            parts.append(TreeNode("f_integrate", [rest, V1]))
+        else:
+            return None        # a term with no differential cannot be integrated (was silently dropped)
+    return TreeNode("f_eq", [summation(parts), ZERO])
+
+
+# --------------------------------------------------------------------------- #
+# Derivative bookkeeping
+# --------------------------------------------------------------------------- #
+def order(eq, m=0):
+    if eq.name in ("f_pdif", "f_dif"):
+        return order(eq.children[0], m + 1)
+    return max([m] + [order(child, m) for child in eq.children])
+
+
+def subs2(eq, orde):
+    if not eq.children:
+        return eq
+    if eq.name in ("f_dif", "f_pdif") and len(eq.children) == 2:
+        if orde == 1:
+            return eq.children[0].fx("dif") / eq.children[1].fx("dif")
+        return eq
+    return TreeNode(eq.name, [subs2(child, orde) for child in eq.children])
+
+
+def subs3(eq):
+    """Push dif through sums and products (sum / product rule)."""
+    if not eq.children:
+        return eq
+    if eq.name == "f_dif":
+        inner = eq.children[0]
+        if inner.name == "f_add":
+            return summation([subs3(c.fx("dif")) for c in inner.children])
+        if inner.name == "f_mul":
+            kids = inner.children
+            return summation([
+                product([subs3(c.fx("dif")) if i == j else c for j, c in enumerate(kids)])
+                for i in range(len(kids))
+            ])
+    return TreeNode(eq.name, [subs3(child) for child in eq.children])
+
+
+# --------------------------------------------------------------------------- #
+# Coefficient collection
+# --------------------------------------------------------------------------- #
+def collect_term(eq, term_lst):
+    """Split eq into  sum(coef[t] * t for t in term_lst) + other.  Returns [coef_dict, other]."""
+    ordered = sorted(term_lst, key=lambda x: -len(factor_generation(x)))   # most specific first
+    counters = [(t, Counter(factor_generation(t))) for t in ordered]       # built once, not per term
+    parts = {t: [] for t, _ in counters}
+    other = []
+    for term in _terms(eq):
+        tc = Counter(factor_generation(term))
+        for t, c in counters:
+            if (tc & c) == c:
+                parts[t].append(product(clist(tc - c)))
+                break
+        else:
+            other.append(term)
+    coef = {t: (simplify(summation(p)) if p else ZERO) for t, p in parts.items()}
+    return [coef, simplify(summation(other)) if other else ZERO]
+
+def linear_dif(eq, a, b):
+    """db + p*b*da - q*da = 0  ->  integrating-factor solution."""
+    eq = simplify(eq)
+    db, da = b.fx("dif"), a.fx("dif")
+    bda = b * da
+    coef, other = collect_term(_expr(eq), [db, bda, da])
+    if other != ZERO:
+        return None
+    lead = coef[db]
+    if lead == ZERO:
+        return None
+    p = simplify(coef[bda] / lead)
+    q = simplify(-(coef[da] / lead))
+    if contain(p, b) or contain(q, b):
+        return None
+    f = E ** TreeNode("f_integrate", [p, a])
+    return simplify(TreeNode("f_eq", [b * f, TreeNode("f_integrate", [q * f, a]) + allocvar()]))
+
+
+def diffsolve(eq):
+    orig = eq.copy_tree()
+    eq = subs2(eq, order(eq))
+    eq = fraction(simplify(fraction(eq)))
+    n = order(eq)
+
+    if n != 1:                       # only first order are handled
+        return orig
+
+    # 1) directly separable
+    sol = diffsolve_sep2(diffsolve_sep(eq))
+    if sol is not None:
+        return sol
+
+    # 2) homogeneous: substitute b = b*a, separate, substitute back
+    first = subs2(orig, 1)           # same for both loop iterations
+    for i in (0, 1):
+        a, b = V[i], V[1 - i]
+        eq2 = subs3(replace(first, b, b * a))
+        eq2 = simplify(fraction(simplify(eq2)))
+        eq2 = diffsolve_sep2(diffsolve_sep(eq2))
+        if eq2 is not None:
+            return e0(TreeNode("f_subs", [replace(eq2.children[0], b, V2), V2, b / a]).fx("try"))
+
+    # 3) linear first order
+    eq = fraction(subs2(simplify(orig), 1))
+    for i in (0, 1):
+        out = linear_dif(eq, V[i], V[1 - i])
+        if out is not None:
+            return out
+    return orig

{mathai-2.5.0 → mathai-2.5.2}/mathai/pde.py

@@ -4,6 +4,7 @@ from .ode import diffsolve as ode_solve
 from .integrate import integrate_formula
 from .simplify import simplify
 from .formula_applier import formula_applier
+from .formula_compiler import formula_list_compiler
 
 pde_character_s = """a*pdif(u,x)+b*pdif(u,y)+c=0 list(dif(x,y)=a/b,dif(u,x)=-c/a,dif(u,y)=-c/b,u) [[c,0],[a,1],[b,1]] [u,x,y] _ _ _"""
 pde_character = lambda x: formula_applier(x, pde_character_s)

{mathai-2.5.0 → mathai-2.5.2}/mathai/printeq.py

@@ -1,5 +1,4 @@
 from .base import *
-from .factor import merge_sqrt
 from .simplify import simplify
 import copy
 from fractions import Fraction

{mathai-2.5.0 → mathai-2.5.2}/mathai/trig.py

@@ -7,7 +7,6 @@ from .base import *
 from .expand import expand
 from .parser import parse
 from .fraction import fraction
-from .factor import rationalize_sqrt
 from .inverse import inverse
 from .formula_compiler import formula_list_compiler
 from .univariate_inequality import simple_wavycurvy, eq2range, Range, range2eq2

{mathai-2.5.0 → mathai-2.5.2}/mathai.egg-info/PKG-INFO

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

{mathai-2.5.0 → mathai-2.5.2}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="mathai",
-    version="2.5.0",
+    version="2.5.2",
     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.5.0/mathai/factor.py

@@ -1,187 +0,0 @@
-import itertools
-from .parser import parse
-from .base import *
-from .simplify import simplify, convert_to_basic
-from .expand import expand
-import math
-from .tool import poly
-from .fraction import fraction
-from collections import Counter
-from .formula_compiler import formula_list_compiler
-
-factor2 = formula_list_compiler("poly(x,a,b,c) a*(x-(-b+sqrt(b^2-4*a*c))/(2*a))*(x-(-b-sqrt(b^2-4*a*c))/(2*a)) [] _ _ b^2-4*a*c _")
-def multiset_intersection(*lists):
-    counters = list(map(Counter, lists))
-    common = counters[0]
-    for c in counters[1:]:
-        common = common & c
-    return list(common.elements())
-def subtract_sublist(full_list, sublist):
-    c_full = Counter(full_list)
-    c_sub = Counter(sublist)
-    result = c_full - c_sub
-    tmp = list(result.elements())
-    if tmp == []:
-        return [tree_form("d_1")]
-    return tmp
-def term_common2(lst, take_neg_common=False):
-    s = []
-    arr = [factor_generation(child,True) for child in lst]
-    if take_neg_common and not all(tree_form("d_-1") not in item for item in arr):
-        arr = [item+[tree_form("d_-1"), tree_form("d_-1")] if tree_form("d_-1") not in item else item for item in arr]
-    s = multiset_intersection(*arr)
-    if s == []:
-        return simplify(summation(lst))
-    arr = [subtract_sublist(item, s) for item in arr]
-    return simplify(product(s)*summation([product(item) for item in arr]))
-def take_common(eq):
-    score = []
-    output = []
-    def helper(eq, depth=0):
-        nonlocal score
-        nonlocal output
-        key = tuple(sorted(eq,key=lambda x: str_form(x)))
-        if key in output:
-            return
-        else:
-            score.append(depth)
-            output.append(key)
-        for item3 in partitions(eq):
-            for option in [False, True]:
-                item = [term_common2(item2, option) for item2 in item3]  
-                helper(item, depth+1)
-    if eq.name == "f_add":
-        helper(eq.children)
-    else:
-        return [eq]
-    sc = {}
-    for i in range(len(output)):
-        output[i] = simplify(summation(list(output[i])))
-        sc[output[i]] = score[i]
-    output = list(set(output))
-    return list(sorted(output, key=lambda x: -sc[x]))
-def _factorconst(eq):
-    def hcf_list(numbers):
-        if not numbers:
-            return None
-        n = 1
-        if math.prod(numbers) < 0:
-            n = -1
-        hcf = numbers[0]
-        for num in numbers[1:]:
-            hcf = math.gcd(hcf, abs(num))
-        return hcf*n
-    def extractnum(eq):
-        lst = factor_generation(eq)
-        for item in lst:
-            if item.name[:2] == "d_":
-                return int(item.name[2:])
-        return 1
-    n = 1
-    if eq.name == "f_add":
-        n = hcf_list([extractnum(child) for child in eq.children])
-        eq = TreeNode(eq.name, [child/tree_form("d_"+str(n)) for child in eq.children])
-    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))
-        if eq.name == "f_pow" and frac(eq.children[1]) == Fraction(-1,2):
-            if frac(eq.children[0]) is not None:
-                out = frac(eq.children[0])
-                b, a = [tree_form("d_"+str(x)) for x in [out.numerator, out.denominator]]
-                return a**(tree_form("d_2")**-1)/b**(tree_form("d_2")**-1)
-        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 max_depth(node):
-    if node is None:
-        return 0
-    if not node.children:
-        return 1
-    return 1 + max(max_depth(child) for child in node.children)
-def factor(equation):
-    if equation.name == "f_add": 
-        lst = take_common(equation)
-        lst3 = lst
-        mx = min([len(item.children) for item in lst3])
-        lst3 = [item for item in lst3 if len(item.children)==mx]
-        tmp = max(lst3, key=lambda x: -max_depth(x))
-        if equation != tmp:
-            return tmp
-    return TreeNode(equation.name, [factor(child) for child in equation.children])

mathai-2.5.0/mathai/ode.py

@@ -1,296 +0,0 @@
-import itertools
-from collections import Counter
-from .diff import diff
-from .factor import factor, factor2, take_common, term_common2
-from .expand import expand
-from .base import *
-from .fraction import fraction
-from .simplify import simplify
-import copy
-from .inverse import inverse
-from .parser import parse
-def rev(eq):
-    tmp = factor_generation(eq)
-    if tree_form("v_0").fx("dif")**-1 in tmp or tree_form("v_1").fx("dif")**-1 in  tmp:
-        return False
-    for child in eq.children:
-        if not rev(child):
-            return False
-    return True
-def clr(eq):
-    return simplify(product([item for item in factor_generation(eq) if "f_add" in str_form(item)]))
-def tt(eq):
-    if eq.name == "f_add":
-        return term_common2(eq.children)
-    return eq
-def shift(lhs, rhs):
-    if isinstance(lhs, list):
-        lhs = simplify(summation(lhs))
-    if isinstance(rhs, list):
-        rhs = simplify(summation(rhs))
-    rhs = simplify(-rhs)
-    out2 = [factor_generation(lhs), factor_generation(rhs)]
-    out = [[], []]
-    for i in range(2):
-        for j in range(len(out2[i])-1,-1,-1):
-            if contain(out2[i][j], tree_form(f"v_{1-i}")) and not contain(out2[i][j], tree_form(f"v_{i}")):
-                out[1-i].append(out2[i].pop(j))
-    output = [simplify(product(out2[i])*product(out[i])**tree_form("d_-1")) for i in range(2)]
-    if ("f_dif" in str_form(output[0]) or "f_dif" in str_form(output[1])) and tree_form("v_0").fx("dif") not in factor_generation(output[0]):
-        output = [tree_form("d_1")/item for item in output]
-    return output
-def check(eq):
-    for item in factor_generation(eq):
-        if contain(item, tree_form("v_0")) and contain(item, tree_form("v_1")) :
-            return False
-    return True
-def t(eq):
-    eq2 = simplify(summation(eq))
-    lst = take_common(eq2)
-    for item in lst:
-        if item.name == "f_add" and len(item.children) == 2:
-           if all(check(child) for child in item.children):
-               return item
-        elif check(item):
-            return item
-    return eq2
-def inversediff(lhs, rhs, old=None):
-    if old is None:
-        old = []
-    if lhs is None or rhs is None:
-        return None
-    eq = simplify(lhs - rhs)
-    eq = tt(eq)
-    eq = clr(eq)
-    eq = t(eq.children)
-    xonly = []
-    yonly = []
-    mixed = []
-    const = []
-    lst = []
-    if eq.name != "f_add":
-        lst.append(eq)
-    else:
-        lst = eq.children
-    for item in lst:
-        con_x = contain(item, tree_form("v_0"))
-        con_y = contain(item, tree_form("v_1"))
-        if not con_x and not con_y:
-            const.append(item)
-        elif con_x and con_y:
-            mixed.append(item)
-        elif con_x:
-            xonly.append(item)
-        elif con_y:
-            yonly.append(item)
-    if len(const) > 0:
-        if len(yonly) > 0:
-            yonly += const
-        else:
-            xonly += const
-    if eq in old:
-        return None
-    if len(mixed) == 0:
-        tmp = shift(lhs, -rhs)
-        return simplify(lhs-rhs)
-    elif len(mixed) > 0:
-        m = t(mixed)
-        if m.name == "f_add":
-            mixed = m.children
-        else:
-            mixed = [m]
-        if len(yonly) > 0 and len(xonly) > 0:
-            tmp = inversediff(*(shift(t(mixed + xonly), yonly)+[old+[eq]]))
-            if tmp is None:
-                tmp = inversediff(*(shift(xonly, t(mixed + yonly))+[old+[eq]]))
-                if tmp is None:
-                    return None
-            return tmp
-        elif len(yonly) > 0:
-            if m.name == "f_add":
-                return None
-            return inversediff(*(shift(m, yonly)+[old+[eq]]))
-        elif len(xonly) > 0:
-            if m.name == "f_add":
-                return None
-            return inversediff(*(shift(xonly, m)+[old+[eq]]))
-        else:
-            if len(mixed) == 2:
-                return inversediff(*(shift(*mixed)+[old+[eq]]))
-    return None
-def allocvar():
-    return tree_form("v_101")
-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):
-    lst = None
-    if eq is None:
-        return None
-    if eq.name == "f_add":
-        lst = list(eq.children)
-    else:
-        lst = [eq]
-    s = [allocvar()]
-    for item in lst:
-        item = simplify(item)
-        tmp = factor_generation(item)
-        tmp2 = product([k for k in tmp if k.name != "f_dif"])
-        if tree_form("v_0").fx("dif") in tmp:
-            s.append(TreeNode("f_integrate", [tmp2, tree_form("v_0")]))
-        elif tree_form("v_1").fx("dif") in tmp:
-            s.append(TreeNode("f_integrate", [tmp2, tree_form("v_1")]))
-    return TreeNode("f_eq", [summation(s), tree_form("d_0")])
-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 = diff2(eq)
-    eq = subs2(eq, order(eq))
-    eq = fraction(simplify(fraction(eq)))
-    if order(eq) == 2:
-        for i in range(2):
-            out = second_order_dif(eq, tree_form(f"v_{i}"), tree_form(f"v_{1-i}"))
-            if out is not None:
-                return out
-        return orig
-    eq = diffsolve_sep2(diffsolve_sep(eq))
-    if eq is None:
-        for i in range(2):
-            a = tree_form(f"v_{i}")
-            b = tree_form(f"v_{1-i}")
-            c = tree_form("v_2")
-            eq2 = orig
-            eq2 = subs2(eq2, 1)
-            eq2 = replace(eq2, b, b*a)
-            eq2 = subs3(eq2)
-            eq2 = simplify(fraction(simplify(eq2)))
-            eq2 = diffsolve_sep(eq2)
-            eq2 = diffsolve_sep2(eq2)
-            if eq2 is not None:
-                return e0(TreeNode("f_subs", [replace(eq2.children[0],b,c), c,b/a]).fx("try"))
-        eq = orig
-        eq = simplify(eq)
-        eq = subs2(eq, 1)
-        eq = fraction(eq)
-        for i in range(2):
-            out = linear_dif(eq, tree_form(f"v_{i}"), tree_form(f"v_{1-i}"))
-            if out is not None:
-                return out
-        return orig
-    else:
-        return eq
-def clist(x):
-    return list(x.elements())
-def collect_term(eq, term_lst):
-    lst = None
-    if eq.name == "f_add":
-        lst = copy.deepcopy(eq.children)
-    else:
-        lst = [eq]
-    other = []
-    dic = {}
-    term_lst = list(sorted(term_lst, key=lambda x: -len(factor_generation(x))))
-    for item in term_lst:
-        dic[item] = tree_form("d_0")
-    for item2 in lst:
-        done = True
-        tmp2 = Counter(factor_generation(item2))
-        for index, item in enumerate(term_lst):
-            tmp = Counter(factor_generation(item))
-            if (tmp2&tmp) == tmp:
-                if item in dic.keys():
-                    dic[item] += product(clist(tmp2-tmp))
-                else:
-                    dic[item] = product(clist(tmp2-tmp))
-                done = False
-                break
-        if done:
-            other.append(item2)
-    other = summation(other)
-    for key in dic.keys():
-        dic[key] = simplify(dic[key])
-    return [dic, simplify(other)]
-def order(eq,m=0):
-    best = m
-    if eq.name in ["f_pdif", "f_dif"]:
-        out = order(eq.children[0], m+1)
-        best = max(out, best)
-    else:
-        for child in eq.children:
-            out = order(child, m)
-            best = max(out, best)
-    return best
-def subs2(eq, orde):
-    if eq.name in ["f_dif", "f_pdif"] and len(eq.children) == 2:
-        if orde == 1:
-            return eq.children[0].fx("dif")/eq.children[1].fx("dif")
-        else:
-            return eq
-    return TreeNode(eq.name, [subs2(child, orde) for child in eq.children])
-def subs3(eq):
-    if eq.name == "f_dif" and eq.children[0].name == "f_add":
-        return summation([subs3(child.fx("dif")) for child in eq.children[0].children])
-    if eq.name == "f_dif" and eq.children[0].name == "f_mul":
-        return summation([product([subs3(child.fx("dif")) if index==index2 else child for index2, child in enumerate(eq.children[0].children)]) for index in range(len(eq.children[0].children))])
-    return TreeNode(eq.name, [subs3(child) for child in eq.children])
-def second_order_dif(eq, a, b):
-    eq = simplify(eq)
-    nn = [TreeNode("f_dif", [TreeNode("f_dif", [b,a]),a]), TreeNode("f_dif", [b,a]), b]
-    out = collect_term(eq.children[0], nn)
-    if out[1] == tree_form("d_0"):
-        tmp = out[0][nn[0]]
-        if tmp != tree_form("d_0"):
-            for key in out[0].keys():
-                out[0][key] = simplify(out[0][key]/tmp)
-            B = out[0][nn[1]]
-            C = out[0][nn[2]]
-            if all(all(not contain(item, item2) for item2 in [a,b]) for item in [B, C]):
-                r = parse("r")
-                s = simplify(factor2(simplify(TreeNode("f_eq", [r**2 + B*r + C, tree_form("d_0")])), True))
-                r1, r2 = [inverse(item, r.name) for item in s.children[0].children]
-                out = None
-                if contain(r1, tree_form("s_i")):
-                    real = simplify(fraction((r1+r2)/tree_form("d_2")))
-                    imagine = simplify((r1-real)/tree_form("s_i"))
-                    out = tree_form("s_e")**(real*a)*(tree_form("v_101")*(imagine*a).fx("cos")+tree_form("v_102")*(imagine*a).fx("sin"))
-                elif fraction(simplify(r1-r2)) == tree_form("d_0"):
-                    out =(tree_form("v_101")+tree_form("v_102")*a)*tree_form("s_e")**(r1*a)
-                else:
-                    out = tree_form("v_101")*tree_form("s_e")**(r1*a) + tree_form("v_102")*tree_form("s_e")**(r2*a)
-                return TreeNode("f_eq", [b, out])
-    return None 
-def linear_dif(eq, a, b):
-    eq = simplify(eq)
-    out = collect_term(eq.children[0], [b.fx("dif"), b*a.fx("dif"), a.fx("dif")])
-    if out[1] == tree_form("d_0"):
-        tmp = out[0][b.fx("dif")]
-        if tmp != tree_form("d_0"):
-            for key in out[0].keys():
-                out[0][key] = simplify(out[0][key]/tmp)
-            p, q = out[0][b*a.fx("dif")], -out[0][a.fx("dif")]
-            if contain(p, b) or contain(q, b):
-                return None
-            f = tree_form("s_e") ** TreeNode("f_integrate", [p, a])
-            return simplify(TreeNode("f_eq", [b*f, TreeNode("f_integrate", [q*f, a])+allocvar()]))
-    return None