def test_numpy_matrix():
if not numpy:
skip("numpy not installed.")
A = Matrix([[x, x * y], [sin(z) + 4, x**z]])
sol_arr = numpy.array([[1, 2], [numpy.sin(3) + 4, 1]])
#Lambdify array first, to ensure return to array as default
f = lambdify((x, y, z), A, ['numpy'])
numpy.testing.assert_allclose(f(1, 2, 3), sol_arr)
#Check that the types are arrays and matrices
assert isinstance(f(1, 2, 3), numpy.ndarray)
# gh-15071
class dot(Function):
pass
x_dot_mtx = dot(x, Matrix([[2], [1], [0]]))
f_dot1 = lambdify(x, x_dot_mtx)
inp = numpy.zeros((17, 3))
assert numpy.all(f_dot1(inp) == 0)
strict_kw = dict(allow_unknown_functions=False,
inline=True,
fully_qualified_modules=False)
p2 = NumPyPrinter(dict(user_functions={'dot': 'dot'}, **strict_kw))
f_dot2 = lambdify(x, x_dot_mtx, printer=p2)
assert numpy.all(f_dot2(inp) == 0)
p3 = NumPyPrinter(strict_kw)
# The line below should probably fail upon construction (before calling with "(inp)"):
raises(Exception, lambda: lambdify(x, x_dot_mtx, printer=p3)(inp))
def test_airy_prime():
from sympy import airyaiprime, airybiprime
expr1 = airyaiprime(x)
expr2 = airybiprime(x)
prntr = SciPyPrinter()
assert prntr.doprint(expr1) == 'scipy.special.airy(x)[1]'
assert prntr.doprint(expr2) == 'scipy.special.airy(x)[3]'
prntr = NumPyPrinter()
assert prntr.doprint(
expr1
) == ' # Not supported in Python with NumPy:\n # airyaiprime\nairyaiprime(x)'
assert prntr.doprint(
expr2
) == ' # Not supported in Python with NumPy:\n # airybiprime\nairybiprime(x)'
prntr = PythonCodePrinter()
assert prntr.doprint(
expr1
) == ' # Not supported in Python:\n # airyaiprime\nairyaiprime(x)'
assert prntr.doprint(
expr2
) == ' # Not supported in Python:\n # airybiprime\nairybiprime(x)'
def test_sqrt():
prntr = PythonCodePrinter()
assert prntr._print_Pow(sqrt(x), rational=False) == 'math.sqrt(x)'
assert prntr._print_Pow(1 / sqrt(x), rational=False) == '1/math.sqrt(x)'
prntr = PythonCodePrinter({'standard': 'python2'})
assert prntr._print_Pow(sqrt(x), rational=True) == 'x**(1./2.)'
assert prntr._print_Pow(1 / sqrt(x), rational=True) == 'x**(-1./2.)'
prntr = PythonCodePrinter({'standard': 'python3'})
assert prntr._print_Pow(sqrt(x), rational=True) == 'x**(1/2)'
assert prntr._print_Pow(1 / sqrt(x), rational=True) == 'x**(-1/2)'
prntr = MpmathPrinter()
assert prntr._print_Pow(sqrt(x), rational=False) == 'mpmath.sqrt(x)'
assert prntr._print_Pow(sqrt(x), rational=True) == \
"x**(mpmath.mpf(1)/mpmath.mpf(2))"
prntr = NumPyPrinter()
assert prntr._print_Pow(sqrt(x), rational=False) == 'numpy.sqrt(x)'
assert prntr._print_Pow(sqrt(x), rational=True) == 'x**(1/2)'
prntr = SciPyPrinter()
assert prntr._print_Pow(sqrt(x), rational=False) == 'numpy.sqrt(x)'
assert prntr._print_Pow(sqrt(x), rational=True) == 'x**(1/2)'
prntr = SymPyPrinter()
assert prntr._print_Pow(sqrt(x), rational=False) == 'sympy.sqrt(x)'
assert prntr._print_Pow(sqrt(x), rational=True) == 'x**(1/2)'
def test_issue_16535_16536():
from sympy import lowergamma, uppergamma
a = symbols('a')
expr1 = lowergamma(a, x)
expr2 = uppergamma(a, x)
prntr = SciPyPrinter()
assert prntr.doprint(
expr1) == 'scipy.special.gamma(a)*scipy.special.gammainc(a, x)'
assert prntr.doprint(
expr2) == 'scipy.special.gamma(a)*scipy.special.gammaincc(a, x)'
prntr = NumPyPrinter()
assert prntr.doprint(
expr1
) == ' # Not supported in Python with NumPy:\n # lowergamma\nlowergamma(a, x)'
assert prntr.doprint(
expr2
) == ' # Not supported in Python with NumPy:\n # uppergamma\nuppergamma(a, x)'
prntr = PythonCodePrinter()
assert prntr.doprint(
expr1
) == ' # Not supported in Python:\n # lowergamma\nlowergamma(a, x)'
assert prntr.doprint(
expr2
) == ' # Not supported in Python:\n # uppergamma\nuppergamma(a, x)'
def test_fresnel_integrals():
from sympy import fresnelc, fresnels
expr1 = fresnelc(x)
expr2 = fresnels(x)
prntr = SciPyPrinter()
assert prntr.doprint(expr1) == 'scipy.special.fresnel(x)[1]'
assert prntr.doprint(expr2) == 'scipy.special.fresnel(x)[0]'
prntr = NumPyPrinter()
assert prntr.doprint(
expr1
) == ' # Not supported in Python with NumPy:\n # fresnelc\nfresnelc(x)'
assert prntr.doprint(
expr2
) == ' # Not supported in Python with NumPy:\n # fresnels\nfresnels(x)'
prntr = PythonCodePrinter()
assert prntr.doprint(
expr1) == ' # Not supported in Python:\n # fresnelc\nfresnelc(x)'
assert prntr.doprint(
expr2) == ' # Not supported in Python:\n # fresnels\nfresnels(x)'
prntr = MpmathPrinter()
assert prntr.doprint(expr1) == 'mpmath.fresnelc(x)'
assert prntr.doprint(expr2) == 'mpmath.fresnels(x)'
def test_sqrt():
prntr = PythonCodePrinter()
assert prntr._print_Pow(sqrt(x), rational=False) == "math.sqrt(x)"
assert prntr._print_Pow(1 / sqrt(x), rational=False) == "1/math.sqrt(x)"
prntr = PythonCodePrinter({"standard": "python2"})
assert prntr._print_Pow(sqrt(x), rational=True) == "x**(1./2.)"
assert prntr._print_Pow(1 / sqrt(x), rational=True) == "x**(-1./2.)"
prntr = PythonCodePrinter({"standard": "python3"})
assert prntr._print_Pow(sqrt(x), rational=True) == "x**(1/2)"
assert prntr._print_Pow(1 / sqrt(x), rational=True) == "x**(-1/2)"
prntr = MpmathPrinter()
assert prntr._print_Pow(sqrt(x), rational=False) == "mpmath.sqrt(x)"
assert (prntr._print_Pow(
sqrt(x), rational=True) == "x**(mpmath.mpf(1)/mpmath.mpf(2))")
prntr = NumPyPrinter()
assert prntr._print_Pow(sqrt(x), rational=False) == "numpy.sqrt(x)"
assert prntr._print_Pow(sqrt(x), rational=True) == "x**(1/2)"
prntr = SciPyPrinter()
assert prntr._print_Pow(sqrt(x), rational=False) == "numpy.sqrt(x)"
assert prntr._print_Pow(sqrt(x), rational=True) == "x**(1/2)"
prntr = SymPyPrinter()
assert prntr._print_Pow(sqrt(x), rational=False) == "sympy.sqrt(x)"
assert prntr._print_Pow(sqrt(x), rational=True) == "x**(1/2)"
def test_autograd_numpy_jacobian():
if not autograd_numpy:
skip("autograd not installed.")
# When the output is a matrix we need modules="autograd.numpy"
f = Matrix([2 * x, x**2])
f_lmbda = lambdify(x, f, modules="autograd.numpy")
f_jac = autograd.jacobian(f_lmbda)
assert autograd_numpy.array_equal(f_jac(2.),
autograd_numpy.array([[2.], [4.]]))
g = Matrix([x * y, y**2 * z])
g_lmbda = lambdify((x, y, z), g, modules="autograd.numpy")
# Need a wrapper so that the argument is a single vector
def gv_lmbda(xx):
return g_lmbda(*xx)
g_jac = autograd.jacobian(gv_lmbda)
# for a function mapping dimensions (i1, i2, ...) -> (o1, o2, ...)
# the jacobian has dimensions (o1, o2, ..., i1, i2, ...)
# In this case we have (3,) -> (2, 1) hence jacobian is (2, 1, 3)
assert autograd_numpy.array_equal(
g_jac(autograd_numpy.array([1., 2., 3.])),
autograd_numpy.array([[[2., 1., 0.]], [[0., 12., 4.]]]))
# gh-15071
class dot(Function):
pass
x_dot_mtx = dot(x, Matrix([[2], [1], [0]]))
f_dot1 = lambdify(x, x_dot_mtx)
inp = numpy.zeros((17, 3))
assert numpy.all(f_dot1(inp) == 0)
strict_kw = dict(allow_unknown_functions=False,
inline=True,
fully_qualified_modules=False)
p2 = NumPyPrinter(dict(user_functions={'dot': 'dot'}, **strict_kw))
f_dot2 = lambdify(x, x_dot_mtx, printer=p2)
assert numpy.all(f_dot2(inp) == 0)
p3 = NumPyPrinter(strict_kw)
# The line below should probably fail upon construction (before calling with "(inp)"):
raises(Exception, lambda: lambdify(x, x_dot_mtx, printer=p3)(inp))
def test_NumPyPrinter():
from sympy import (
Lambda,
ZeroMatrix,
OneMatrix,
FunctionMatrix,
HadamardProduct,
KroneckerProduct,
Adjoint,
DiagonalOf,
DiagMatrix,
DiagonalMatrix,
)
from sympy.abc import a, b
p = NumPyPrinter()
assert p.doprint(sign(x)) == "numpy.sign(x)"
A = MatrixSymbol("A", 2, 2)
B = MatrixSymbol("B", 2, 2)
C = MatrixSymbol("C", 1, 5)
D = MatrixSymbol("D", 3, 4)
assert p.doprint(A**(-1)) == "numpy.linalg.inv(A)"
assert p.doprint(A**5) == "numpy.linalg.matrix_power(A, 5)"
assert p.doprint(Identity(3)) == "numpy.eye(3)"
u = MatrixSymbol("x", 2, 1)
v = MatrixSymbol("y", 2, 1)
assert p.doprint(MatrixSolve(A, u)) == "numpy.linalg.solve(A, x)"
assert p.doprint(MatrixSolve(A, u) + v) == "numpy.linalg.solve(A, x) + y"
assert p.doprint(ZeroMatrix(2, 3)) == "numpy.zeros((2, 3))"
assert p.doprint(OneMatrix(2, 3)) == "numpy.ones((2, 3))"
assert (p.doprint(FunctionMatrix(4, 5, Lambda(
(a, b), a + b))) == "numpy.fromfunction(lambda a, b: a + b, (4, 5))")
assert p.doprint(HadamardProduct(A, B)) == "numpy.multiply(A, B)"
assert p.doprint(KroneckerProduct(A, B)) == "numpy.kron(A, B)"
assert p.doprint(Adjoint(A)) == "numpy.conjugate(numpy.transpose(A))"
assert p.doprint(DiagonalOf(A)) == "numpy.reshape(numpy.diag(A), (-1, 1))"
assert p.doprint(DiagMatrix(C)) == "numpy.diagflat(C)"
assert p.doprint(DiagonalMatrix(D)) == "numpy.multiply(D, numpy.eye(3, 4))"
# Workaround for numpy negative integer power errors
assert p.doprint(x**-1) == "x**(-1.0)"
assert p.doprint(x**-2) == "x**(-2.0)"
assert p.doprint(S.Exp1) == "numpy.e"
assert p.doprint(S.Pi) == "numpy.pi"
assert p.doprint(S.EulerGamma) == "numpy.euler_gamma"
assert p.doprint(S.NaN) == "numpy.nan"
assert p.doprint(S.Infinity) == "numpy.PINF"
assert p.doprint(S.NegativeInfinity) == "numpy.NINF"
def test_NumPyPrinter():
p = NumPyPrinter()
assert p.doprint(sign(x)) == 'numpy.sign(x)'
A = MatrixSymbol("A", 2, 2)
assert p.doprint(A**(-1)) == "numpy.linalg.inv(A)"
assert p.doprint(A**5) == "numpy.linalg.matrix_power(A, 5)"
u = MatrixSymbol('x', 2, 1)
v = MatrixSymbol('y', 2, 1)
assert p.doprint(MatrixSolve(A, u)) == 'numpy.linalg.solve(A, x)'
assert p.doprint(MatrixSolve(A, u) + v) == 'numpy.linalg.solve(A, x) + y'
# Workaround for numpy negative integer power errors
assert p.doprint(x**-1) == 'x**(-1.0)'
assert p.doprint(x**-2) == 'x**(-2.0)'
def test_beta():
from sympy import beta
expr = beta(x, y)
prntr = SciPyPrinter()
assert prntr.doprint(expr) == 'scipy.special.beta(x, y)'
prntr = NumPyPrinter()
assert prntr.doprint(expr) == 'math.gamma(x)*math.gamma(y)/math.gamma(x + y)'
prntr = PythonCodePrinter()
assert prntr.doprint(expr) == 'math.gamma(x)*math.gamma(y)/math.gamma(x + y)'
prntr = MpmathPrinter()
assert prntr.doprint(expr) == 'mpmath.beta(x, y)'
def test_frac():
from sympy import frac
expr = frac(x)
prntr = NumPyPrinter()
assert prntr.doprint(expr) == 'numpy.mod(x, 1)'
prntr = SciPyPrinter()
assert prntr.doprint(expr) == 'numpy.mod(x, 1)'
prntr = PythonCodePrinter()
assert prntr.doprint(expr) == 'x % 1'
prntr = MpmathPrinter()
assert prntr.doprint(expr) == 'mpmath.frac(x)'
prntr = SymPyPrinter()
assert prntr.doprint(expr) == 'sympy.functions.elementary.integers.frac(x)'
def test_beta():
from sympy import beta
expr = beta(x, y)
prntr = SciPyPrinter()
assert prntr.doprint(expr) == "scipy.special.beta(x, y)"
prntr = NumPyPrinter()
assert prntr.doprint(
expr) == "math.gamma(x)*math.gamma(y)/math.gamma(x + y)"
prntr = PythonCodePrinter()
assert prntr.doprint(
expr) == "math.gamma(x)*math.gamma(y)/math.gamma(x + y)"
prntr = PythonCodePrinter({"allow_unknown_functions": True})
assert prntr.doprint(
expr) == "math.gamma(x)*math.gamma(y)/math.gamma(x + y)"
prntr = MpmathPrinter()
assert prntr.doprint(expr) == "mpmath.beta(x, y)"
def test_NumPyPrinter():
p = NumPyPrinter()
assert p.doprint(sign(x)) == 'numpy.sign(x)'
A = MatrixSymbol("A", 2, 2)
assert p.doprint(A**(-1)) == "numpy.linalg.inv(A)"
assert p.doprint(A**5) == "numpy.linalg.matrix_power(A, 5)"
assert p.doprint(Identity(3)) == "numpy.eye(3)"
u = MatrixSymbol('x', 2, 1)
v = MatrixSymbol('y', 2, 1)
assert p.doprint(MatrixSolve(A, u)) == 'numpy.linalg.solve(A, x)'
assert p.doprint(MatrixSolve(A, u) + v) == 'numpy.linalg.solve(A, x) + y'
# Workaround for numpy negative integer power errors
assert p.doprint(x**-1) == 'x**(-1.0)'
assert p.doprint(x**-2) == 'x**(-2.0)'
assert p.doprint(S.Exp1) == 'numpy.e'
assert p.doprint(S.Pi) == 'numpy.pi'
assert p.doprint(S.EulerGamma) == 'numpy.euler_gamma'
assert p.doprint(S.NaN) == 'numpy.nan'
assert p.doprint(S.Infinity) == 'numpy.PINF'
assert p.doprint(S.NegativeInfinity) == 'numpy.NINF'
def test_NumPyPrinter():
p = NumPyPrinter()
assert p.doprint(sign(x)) == 'numpy.sign(x)'
def test_NumPyPrinter_print_seq():
n = NumPyPrinter()
assert n._print_seq(range(2)) == '(0, 1,)'
def test_printmethod():
obj = CustomPrintedObject()
assert NumPyPrinter().doprint(obj) == 'numpy'
assert MpmathPrinter().doprint(obj) == 'mpmath'
x, y, r, l, A = sym.symbols("x y r l A")
rdef = sym.sqrt(x**2 + y**2)
# %% [markdown]
# Can sub `sym.sqrt(x**2 + y**2)` later?
# %% [markdown]
# ## Gaussian
# %%
C = A*sym.exp(-r**2/(2*l**2))
C
# %%
C = A*sym.exp(-r**2/(2*l**2))
print(NumPyPrinter().doprint(C))
# %%
R = (-1/r)*sym.diff(C, r)
print(NumPyPrinter().doprint(R))
# %%
S = sym.simplify(-sym.diff(C, r, 2))
print(NumPyPrinter().doprint(S))
# %%
Cuu = sym.simplify(x**2 * (R - S) / r**2 + S)
print(NumPyPrinter().doprint(Cuu))
# %%
Cvv = sym.simplify(y**2 * (R - S) / r**2 + S)
def test_NumPyPrinter():
p = NumPyPrinter()
assert p.doprint(sign(x)) == 'numpy.sign(x)'
A = MatrixSymbol("A", 2, 2)
assert p.doprint(A**(-1)) == "numpy.linalg.inv(A)"
assert p.doprint(A**5) == "numpy.linalg.matrix_power(A, 5)"