def test_octave_not_supported():
assert mcode(S.ComplexInfinity) == (
"% Not supported in Octave:\n"
"% ComplexInfinity\n"
"zoo"
)
f = Function('f')
assert mcode(f(x).diff(x)) == (
"% Not supported in Octave:\n"
"% Derivative\n"
"Derivative(f(x), x)"
)
def test_m_not_supported():
f = Function('f')
name_expr = ("test", [f(x).diff(x), S.ComplexInfinity])
result, = codegen(name_expr, "Octave", header=False, empty=False)
source = result[1]
expected = ("function [out1, out2] = test(x)\n"
" % unsupported: Derivative(f(x), x)\n"
" % unsupported: zoo\n"
" out1 = Derivative(f(x), x);\n"
" out2 = zoo;\n"
"end\n")
assert source == expected
def test_functional_diffgeom_ch4():
x0, y0, theta0 = symbols('x0, y0, theta0', extended_real=True)
x, y, r, theta = symbols('x, y, r, theta', extended_real=True)
r0 = symbols('r0', positive=True)
f = Function('f')
b1 = Function('b1')
b2 = Function('b2')
p_r = R2_r.point([x0, y0])
p_p = R2_p.point([r0, theta0])
f_field = b1(R2.x, R2.y) * R2.dx + b2(R2.x, R2.y) * R2.dy
assert f_field.rcall(R2.e_x).rcall(p_r) == b1(x0, y0)
assert f_field.rcall(R2.e_y).rcall(p_r) == b2(x0, y0)
s_field_r = f(R2.x, R2.y)
df = Differential(s_field_r)
assert df(R2.e_x).rcall(p_r).doit() == Derivative(f(x0, y0), x0)
assert df(R2.e_y).rcall(p_r).doit() == Derivative(f(x0, y0), y0)
s_field_p = f(R2.r, R2.theta)
df = Differential(s_field_p)
assert trigsimp(df(R2.e_x).rcall(p_p).doit()) == (
cos(theta0) * Derivative(f(r0, theta0), r0) -
sin(theta0) * Derivative(f(r0, theta0), theta0) / r0)
assert trigsimp(df(R2.e_y).rcall(p_p).doit()) == (
sin(theta0) * Derivative(f(r0, theta0), r0) +
cos(theta0) * Derivative(f(r0, theta0), theta0) / r0)
assert R2.dx(R2.e_x).rcall(p_r) == 1
assert R2.dx(R2.e_x) == 1
assert R2.dx(R2.e_y).rcall(p_r) == 0
assert R2.dx(R2.e_y) == 0
circ = -R2.y * R2.e_x + R2.x * R2.e_y
assert R2.dx(circ).rcall(p_r).doit() == -y0
assert R2.dy(circ).rcall(p_r) == x0
assert R2.dr(circ).rcall(p_r) == 0
assert simplify(R2.dtheta(circ).rcall(p_r)) == 1
assert (circ - R2.e_theta).rcall(s_field_r).rcall(p_r) == 0
def test_split_symbols_function():
transformations = standard_transformations + \
(split_symbols, implicit_multiplication)
x = Symbol('x')
y = Symbol('y')
a = Symbol('a')
f = Function('f')
assert parse_expr('ay(x+1)',
transformations=transformations) == a * y * (x + 1)
assert parse_expr('af(x+1)',
transformations=transformations,
local_dict={'f': f}) == a * f(x + 1)
def test_ufunc_support():
f = Function('f')
g = Function('g')
x = IndexedBase('x')
y = IndexedBase('y')
i, j = Idx('i'), Idx('j')
assert get_indices(f(x[i])) == ({i}, {})
assert get_indices(f(x[i], y[j])) == ({i, j}, {})
assert get_indices(f(y[i]) * g(x[i])) == (set(), {})
assert get_indices(f(a, x[i])) == ({i}, {})
assert get_indices(f(a, y[i], x[j]) * g(x[i])) == ({j}, {})
assert get_indices(g(f(x[i]))) == ({i}, {})
assert get_contraction_structure(f(x[i])) == {None: {f(x[i])}}
assert get_contraction_structure(f(y[i]) * g(x[i])) == {
(i, ): {f(y[i]) * g(x[i])}
}
assert get_contraction_structure(f(y[i]) * g(f(x[i]))) == {
(i, ): {f(y[i]) * g(f(x[i]))}
}
assert get_contraction_structure(f(x[j], y[i]) * g(x[i])) == {
(i, ): {f(x[j], y[i]) * g(x[i])}
}
def test_get_contraction_structure_basic():
x = IndexedBase('x')
y = IndexedBase('y')
i, j = Idx('i'), Idx('j')
f = Function('f')
assert get_contraction_structure(x[i] * y[j]) == {None: {x[i] * y[j]}}
assert get_contraction_structure(x[i] + y[j]) == {None: {x[i], y[j]}}
assert get_contraction_structure(x[i] * y[i]) == {(i, ): {x[i] * y[i]}}
assert get_contraction_structure(1 + x[i] * y[i]) == {
None: {1},
(i, ): {x[i] * y[i]}
}
assert get_contraction_structure(x[i]**y[i]) == {None: {x[i]**y[i]}}
assert (get_contraction_structure(f(x[i, i])) == {
None: {f(x[i, i])},
f(x[i, i]): [{
(i, ): {x[i, i]}
}]
})
def test_sympyissue_11799():
n = 2
M = Manifold('M', n)
P = Patch('P', M)
coord = CoordSystem('coord', P, ['x%s' % i for i in range(n)])
x = coord.coord_functions()
dx = coord.base_oneforms()
f = Function('f')
g = [[f(x[0], x[1])**2, 0], [0, f(x[0], x[1])**2]]
metric = sum(g[i][j]*TP(dx[i], dx[j]) for i in range(n) for j in range(n))
R = metric_to_Riemann_components(metric)
d = Symbol('d')
assert (R[0, 1, 0, 1] ==
-Subs(Derivative(f(d, x[1]), d, d), (d, x[0]))/f(x[0], x[1]) -
Subs(Derivative(f(x[0], d), d, d), (d, x[1]))/f(x[0], x[1]) +
Subs(Derivative(f(d, x[1]), d), (d, x[0]))**2/f(x[0], x[1])**2 +
Subs(Derivative(f(x[0], d), d), (d, x[1]))**2/f(x[0], x[1])**2)
from diofant.functions import (Heaviside, Max, Min, Piecewise, acos, acosh,
acot, acoth, asin, asinh, atan, atanh, binomial,
conjugate, cos, cosh, cot, coth, csch, erfc,
exp, factorial, factorial2, fibonacci, gamma,
hyper, im, log, meijerg, polygamma, polylog, re,
rf, sech, sign, sin, sinh, tan, tanh, zeta)
from diofant.integrals import Integral
from diofant.logic import Or, false, true
from diofant.matrices import Matrix, SparseMatrix
from diofant.polys import Poly, RootOf, RootSum
from diofant.series import Limit
__all__ = ()
f = Function('f')
def test_Integer():
assert mcode(Integer(67)) == "67"
assert mcode(Integer(-1)) == "-1"
def test_Rational():
assert mcode(Rational(3, 7)) == "3/7"
assert mcode(Rational(18, 9)) == "2"
assert mcode(Rational(3, -7)) == "-3/7"
assert mcode(Rational(-3, -7)) == "3/7"
assert mcode(x + Rational(3, 7)) == "x + 3/7"
assert mcode(Rational(3, 7)*x) == "(3/7)*x"
def test_Min():
n = Symbol('n', negative=True)
n_ = Symbol('n_', negative=True)
nn = Symbol('nn', nonnegative=True)
nn_ = Symbol('nn_', nonnegative=True)
p = Symbol('p', positive=True)
p_ = Symbol('p_', positive=True)
np = Symbol('np', nonpositive=True)
np_ = Symbol('np_', nonpositive=True)
assert Min(5, 4) == 4
assert Min(-oo, -oo) == -oo
assert Min(-oo, n) == -oo
assert Min(n, -oo) == -oo
assert Min(-oo, np) == -oo
assert Min(np, -oo) == -oo
assert Min(-oo, 0) == -oo
assert Min(0, -oo) == -oo
assert Min(-oo, nn) == -oo
assert Min(nn, -oo) == -oo
assert Min(-oo, p) == -oo
assert Min(p, -oo) == -oo
assert Min(-oo, oo) == -oo
assert Min(oo, -oo) == -oo
assert Min(n, n) == n
assert Min(n, np) == Min(n, np)
assert Min(np, n) == Min(np, n)
assert Min(n, 0) == n
assert Min(0, n) == n
assert Min(n, nn) == n
assert Min(nn, n) == n
assert Min(n, p) == n
assert Min(p, n) == n
assert Min(n, oo) == n
assert Min(oo, n) == n
assert Min(np, np) == np
assert Min(np, 0) == np
assert Min(0, np) == np
assert Min(np, nn) == np
assert Min(nn, np) == np
assert Min(np, p) == np
assert Min(p, np) == np
assert Min(np, oo) == np
assert Min(oo, np) == np
assert Min(0, 0) == 0
assert Min(0, nn) == 0
assert Min(nn, 0) == 0
assert Min(0, p) == 0
assert Min(p, 0) == 0
assert Min(0, oo) == 0
assert Min(oo, 0) == 0
assert Min(nn, nn) == nn
assert Min(nn, p) == Min(nn, p)
assert Min(p, nn) == Min(p, nn)
assert Min(nn, oo) == nn
assert Min(oo, nn) == nn
assert Min(p, p) == p
assert Min(p, oo) == p
assert Min(oo, p) == p
assert Min(oo, oo) == oo
assert isinstance(Min(n, n_), Min)
assert isinstance(Min(nn, nn_), Min)
assert isinstance(Min(np, np_), Min)
assert isinstance(Min(p, p_), Min)
# lists
pytest.raises(ValueError, lambda: Min())
assert Min(x, y) == Min(y, x)
assert Min(x, y, z) == Min(z, y, x)
assert Min(x, Min(y, z)) == Min(z, y, x)
assert Min(x, Max(y, -oo)) == Min(x, y)
assert Min(p, oo, n, p, p, p_) == n
assert Min(p_, n_, p) == n_
assert Min(n, oo, -7, p, p, 2) == Min(n, -7)
assert Min(2, x, p, n, oo, n_, p, 2, -2, -2) == Min(-2, x, n, n_)
assert Min(0, x, 1, y) == Min(0, x, y)
assert Min(1000, 100, -100, x, p, n) == Min(n, x, -100)
assert Min(cos(x), sin(x)) == Min(cos(x), sin(x))
assert Min(cos(x), sin(x)).subs({x: 1}) == cos(1)
assert Min(cos(x), sin(x)).subs({x: Rational(1, 2)}) == sin(Rational(1, 2))
pytest.raises(ValueError, lambda: Min(cos(x), sin(x)).subs({x: I}))
pytest.raises(ValueError, lambda: Min(I))
pytest.raises(ValueError, lambda: Min(I, x))
pytest.raises(ValueError, lambda: Min(zoo, x))
assert Min(1, x).diff(x) == Heaviside(1 - x)
assert Min(x, 1).diff(x) == Heaviside(1 - x)
assert Min(0, -x, 1 - 2*x).diff(x) == -Heaviside(x + Min(0, -2*x + 1)) \
- 2*Heaviside(2*x + Min(0, -x) - 1)
pytest.raises(ArgumentIndexError, lambda: Min(1, x).fdiff(3))
a, b = Symbol('a', extended_real=True), Symbol('b', extended_real=True)
# a and b are both real, Min(a, b) should be real
assert Min(a, b).is_extended_real
# issue sympy/sympy#7619
f = Function('f')
assert Min(1, 2 * Min(f(1), 2)) # doesn't fail
# issue sympy/sympy#7233
e = Min(0, x)
assert e.evalf == e.n
assert e.evalf(strict=False).args == (0, x)
def test_get_indices_Idx():
f = Function('f')
i, j = Idx('i'), Idx('j')
assert get_indices(f(i) * j) == ({i, j}, {})
assert get_indices(f(j, i)) == ({j, i}, {})
assert get_indices(f(i) * i) == (set(), {})
def apart_list_full_decomposition(P, Q, dummygen):
"""
Bronstein's full partial fraction decomposition algorithm.
Given a univariate rational function ``f``, performing only GCD
operations over the algebraic closure of the initial ground domain
of definition, compute full partial fraction decomposition with
fractions having linear denominators.
Note that no factorization of the initial denominator of ``f`` is
performed. The final decomposition is formed in terms of a sum of
:class:`RootSum` instances.
References
==========
.. [1] [Bronstein93]_
"""
f, x, U = P / Q, P.gen, []
u = Function('u')(x)
a = Dummy('a')
partial = []
for d, n in Q.sqf_list_include(all=True):
b = d.as_expr()
U += [u.diff(x, n - 1)]
h = cancel(f * b**n) / u**n
H, subs = [h], []
for j in range(1, n):
H += [H[-1].diff(x) / j]
for j in range(1, n + 1):
subs += [(U[j - 1], b.diff(x, j) / j)]
for j in range(0, n):
P, Q = cancel(H[j]).as_numer_denom()
for i in range(0, j + 1):
P = P.subs(*subs[j - i])
Q = Q.subs(*subs[0])
P = Poly(P, x)
Q = Poly(Q, x)
G = P.gcd(d)
D = d.quo(G)
B, g = Q.half_gcdex(D)
b = (P * B.quo(g)).rem(D)
Dw = D.subs(x, next(dummygen))
numer = Lambda(a, b.as_expr().subs(x, a))
denom = Lambda(a, (x - a))
exponent = n - j
partial.append((Dw, numer, denom, exponent))
return partial
