def test_numpy_array_out_exceptions():
if not HAVE_NUMPY: # nosetests work-around
return
import numpy as np
args, exprs, inp, check = _get_array()
lmb = se.Lambdify(args, exprs)
all_right = np.empty(len(exprs))
lmb(inp, all_right)
too_short = np.empty(len(exprs) - 1)
raises(ValueError, lambda: (lmb(inp, too_short)))
wrong_dtype = np.empty(len(exprs), dtype=int)
raises(TypeError, lambda: (lmb(inp, wrong_dtype)))
read_only = np.empty(len(exprs))
read_only.flags['WRITEABLE'] = False
raises(ValueError, lambda: (lmb(inp, read_only)))
all_right_broadcast = np.empty((2, len(exprs)))
inp_bcast = [[1, 2, 3], [4, 5, 6]]
lmb(np.array(inp_bcast), all_right_broadcast)
f_contig_broadcast = np.empty((2, len(exprs)), order='F')
raises(ValueError, lambda: (lmb(inp_bcast, f_contig_broadcast)))
improper_bcast = np.empty((3, len(exprs)))
raises(ValueError, lambda: (lmb(inp_bcast, improper_bcast)))
def test_var():
var("a")
assert a == Symbol("a")
var("b bb cc zz _x")
assert b == Symbol("b")
assert bb == Symbol("bb")
assert cc == Symbol("cc")
assert zz == Symbol("zz")
assert _x == Symbol("_x")
v = var(['d', 'e', 'fg'])
assert d == Symbol('d')
assert e == Symbol('e')
assert fg == Symbol('fg')
# check return value
assert v == [d, e, fg]
# see if var() really injects into global namespace
raises(NameError, lambda: z1)
_make_z1()
assert z1 == Symbol("z1")
raises(NameError, lambda: z2)
_make_z2()
assert z2 == Symbol("z2")
def test_var():
var("a")
assert a == Symbol("a")
var("b bb cc zz _x")
assert b == Symbol("b")
assert bb == Symbol("bb")
assert cc == Symbol("cc")
assert zz == Symbol("zz")
assert _x == Symbol("_x")
v = var(['d', 'e', 'fg'])
assert d == Symbol('d')
assert e == Symbol('e')
assert fg == Symbol('fg')
# check return value
assert v == [d, e, fg]
# see if var() really injects into global namespace
raises(NameError, lambda: z1)
_make_z1()
assert z1 == Symbol("z1")
raises(NameError, lambda: z2)
_make_z2()
assert z2 == Symbol("z2")
def test_numpy_array_out_exceptions():
if not HAVE_NUMPY: # nosetests work-around
return
import numpy as np
args, exprs, inp, check = _get_array()
lmb = se.Lambdify(args, exprs)
all_right = np.empty(len(exprs))
lmb(inp, all_right)
too_short = np.empty(len(exprs) - 1)
raises(ValueError, lambda: (lmb(inp, too_short)))
wrong_dtype = np.empty(len(exprs), dtype=int)
raises(TypeError, lambda: (lmb(inp, wrong_dtype)))
read_only = np.empty(len(exprs))
read_only.flags['WRITEABLE'] = False
raises(ValueError, lambda: (lmb(inp, read_only)))
all_right_broadcast = np.empty((2, len(exprs)))
inp_bcast = [[1, 2, 3], [4, 5, 6]]
lmb(np.array(inp_bcast), all_right_broadcast)
f_contig_broadcast = np.empty((2, len(exprs)), order='F')
raises(ValueError, lambda: (lmb(inp_bcast, f_contig_broadcast)))
improper_bcast = np.empty((3, len(exprs)))
raises(ValueError, lambda: (lmb(inp_bcast, improper_bcast)))
def test_var_return():
raises(ValueError, lambda: var(''))
v2 = var('q')
v3 = var('q p')
assert v2 == Symbol('q')
assert v3 == (Symbol('q'), Symbol('p'))
def test_var_return():
raises(ValueError, lambda: var(''))
v2 = var('q')
v3 = var('q p')
assert v2 == Symbol('q')
assert v3 == (Symbol('q'), Symbol('p'))
def test_Lambdify_with_opt_level():
args = x, y, z = se.symbols('x y z')
raises(
TypeError,
lambda: se.Lambdify(args, [x + y + z, x**2, (x - y) / z, x * y * z],
backend='lambda',
opt_level=0))
def test_var_global_namespace():
# see if var() really injects into global namespace
raises(NameError, lambda: z1)
_make_z1()
assert z1 == Symbol("z1")
raises(NameError, lambda: z2)
_make_z2()
assert z2 == Symbol("z2")
def test_var_global_namespace():
# see if var() really injects into global namespace
raises(NameError, lambda: z1)
_make_z1()
assert z1 == Symbol("z1")
raises(NameError, lambda: z2)
_make_z2()
assert z2 == Symbol("z2")
def test_add_scalar():
A = DenseMatrix(2, 2, [1, 2, 3, 4])
a = Symbol("a")
assert A.add_scalar(a) == DenseMatrix(2, 2, [1 + a, 2 + a, 3 + a, 4 + a])
i5 = Integer(5)
assert A.add_scalar(i5) == DenseMatrix(2, 2, [6, 7, 8, 9])
raises(TypeError, lambda: A + 5)
raises(TypeError, lambda: 5 + A)
def test_sub():
A = DenseMatrix(2, 2, [1, 2, 3, 4])
B = DenseMatrix(2, 2, [0, -1, -2, -3])
a = Symbol("a")
assert A - 5 == DenseMatrix(2, 2, [-4, -3, -2, -1])
assert a - A == DenseMatrix(2, 2, [a - 1, a - 2, a - 3, a - 4])
assert A - B == DenseMatrix(2, 2, [1, 3, 5, 7])
C = DenseMatrix(2, 1, [1, 2])
raises(ShapeError, lambda: A - C)
def test_CCodePrinter():
x = Symbol("x")
y = Symbol("y")
myprinter = CCodePrinter()
assert myprinter.doprint(1+x, "bork") == "bork = 1 + x;"
assert myprinter.doprint(1*x) == "x"
assert myprinter.doprint(MutableDenseMatrix(1, 2, [x, y]), "larry") == "larry[0] = x;\nlarry[1] = y;"
raises(TypeError, lambda: myprinter.doprint(sin(x), Integer))
raises(RuntimeError, lambda: myprinter.doprint(MutableDenseMatrix(1, 2, [x, y])))
def test_n_mpc():
try:
from symengine import ComplexMPC
x = sqrt(Integer(2)) + 3 * I
y = ComplexMPC('1.41421356237309504880169', '3.0', 75)
assert x.n(75) == y
except ImportError:
x = sqrt(Integer(2))
raises(ValueError, lambda: (x.n(75)))
raise SkipTest("No MPC support")
def test_n_mpfr():
x = sqrt(Integer(2))
try:
from symengine import RealMPFR
y = RealMPFR('1.41421356237309504880169', 75)
assert x.n(75, real=True) == y
except ImportError:
raises(ValueError, lambda: (x.n(75, real=True)))
raises(ValueError, lambda: (x.n(75)))
raise SkipTest("No MPFR support")
def test_Lambdify_LLVM():
n = 7
args = x, y, z = se.symbols('x y z')
if not se.have_llvm:
raises(ValueError, lambda: se.Lambdify(args, [x+y+z, x**2, (x-y)/z, x*y*z],
backend='llvm'))
return
l = se.Lambdify(args, [x+y+z, x**2, (x-y)/z, x*y*z], backend='llvm')
assert allclose(l(range(n, n+len(args))),
[3*n+3, n**2, -1/(n+2), n*(n+1)*(n+2)])
def test_sub():
A = DenseMatrix(2, 2, [1, 2, 3, 4])
B = DenseMatrix(2, 2, [0, -1, -2, -3])
a = Symbol("a")
assert A - 5 == DenseMatrix(2, 2, [-4, -3, -2, -1])
assert a - A == DenseMatrix(2, 2, [a - 1, a - 2, a - 3, a - 4])
assert A - B == DenseMatrix(2, 2, [1, 3, 5, 7])
C = DenseMatrix(2, 1, [1, 2])
raises(ShapeError, lambda: A - C)
def test_div():
w, x, y, z = symbols("w, x, y, z")
A = DenseMatrix([[w, x], [y, z]])
B = DenseMatrix([[1, 1], [1, 0]])
C = DenseMatrix([[x, w - x], [z, y - z]])
assert A / 2 == DenseMatrix([[w / 2, x / 2], [y / 2, z / 2]])
assert C * B == A
assert A / B == C
raises(TypeError, lambda: 2 / A)
def test_add_scalar():
A = DenseMatrix(2, 2, [1, 2, 3, 4])
a = Symbol("a")
assert A.add_scalar(a) == DenseMatrix(2, 2, [1 + a, 2 + a, 3 + a, 4 + a])
i5 = Integer(5)
assert A.add_scalar(i5) == DenseMatrix(2, 2, [6, 7, 8, 9])
raises(TypeError, lambda: A + 5)
raises(TypeError, lambda: 5 + A)
def test_Lambdify_LLVM():
n = 7
args = x, y, z = se.symbols('x y z')
if not se.have_llvm:
raises(ValueError, lambda: se.Lambdify(args, [x+y+z, x**2,
(x-y)/z, x*y*z],
backend='llvm'))
raise SkipTest("No LLVM support")
L = se.Lambdify(args, [x+y+z, x**2, (x-y)/z, x*y*z], backend='llvm')
assert allclose(L(range(n, n+len(args))),
[3*n+3, n**2, -1/(n+2), n*(n+1)*(n+2)])
def test_det():
A = DenseMatrix(2, 2, [1, 2, 3, 4])
assert A.det() == -2
a = Symbol("a")
b = Symbol("b")
c = Symbol("c")
d = Symbol("d")
A = DenseMatrix(2, 2, [a, b, c, d])
assert A.det() == a * d - b * c
A = DenseMatrix(3, 2, [1, 2, 3, 4, 5, 6])
raises(NonSquareMatrixError, lambda: A.det())
def test_det():
A = DenseMatrix(2, 2, [1, 2, 3, 4])
assert A.det() == -2
a = Symbol("a")
b = Symbol("b")
c = Symbol("c")
d = Symbol("d")
A = DenseMatrix(2, 2, [a, b, c, d])
assert A.det() == a*d - b*c
A = DenseMatrix(3, 2, [1, 2, 3, 4, 5, 6])
raises(NonSquareMatrixError, lambda: A.det())
def test_get_item():
A = DenseMatrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])
assert A[5] == 6
assert A[-1] == 9
assert A[2, 2] == 9
assert A[-2, 2] == 6
assert A[1:2, 0] == DenseMatrix(1, 1, [4])
assert A[1:3, 0] == DenseMatrix(2, 1, [4, 7])
assert A[1:3, 0] == DenseMatrix(2, 1, [4, 7])
assert A[1:3, 1:] == DenseMatrix(2, 2, [5, 6, 8, 9])
assert A[1:3, :1] == DenseMatrix(2, 1, [4, 7])
assert A[0, 0:] == DenseMatrix(1, 3, [1, 2, 3])
assert A[2, :] == DenseMatrix(1, 3, [7, 8, 9])
assert A[:2, -2:] == DenseMatrix(2, 2, [2, 3, 5, 6])
assert A[1:, :3] == DenseMatrix(2, 3, [4, 5, 6, 7, 8, 9])
assert A[1:] == [2, 3, 4, 5, 6, 7, 8, 9]
assert A[-2:] == [8, 9]
raises(IndexError, lambda: A[-10])
raises(IndexError, lambda: A[9])
raises(IndexError, lambda: A[1:3, 3])
raises(IndexError, lambda: A[1:3, -4])
def test_get_item():
A = DenseMatrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])
assert A[5] == 6
assert A[-1] == 9
assert A[2, 2] == 9
assert A[-2, 2] == 6
assert A[1:2, 0] == DenseMatrix(1, 1, [4])
assert A[1:3, 0] == DenseMatrix(2, 1, [4, 7])
assert A[1:3, 0] == DenseMatrix(2, 1, [4, 7])
assert A[1:3, 1:] == DenseMatrix(2, 2, [5, 6, 8, 9])
assert A[1:3, :1] == DenseMatrix(2, 1, [4, 7])
assert A[0, 0:] == DenseMatrix(1, 3, [1, 2, 3])
assert A[2, :] == DenseMatrix(1, 3, [7, 8, 9])
assert A[:2, -2:] == DenseMatrix(2, 2, [2, 3, 5, 6])
assert A[1:, :3] == DenseMatrix(2, 3, [4, 5, 6, 7, 8, 9])
assert A[1:] == [2, 3, 4, 5, 6, 7, 8, 9]
assert A[-2:] == [8, 9]
raises(IndexError, lambda: A[-10])
raises(IndexError, lambda: A[9])
raises(IndexError, lambda: A[1:3, 3])
raises(IndexError, lambda: A[1:3, -4])
def test_n():
x = Symbol("x")
raises(RuntimeError, lambda: (x.n()))
x = 2 + I
raises(RuntimeError, lambda: (x.n(real=True)))
x = sqrt(Integer(4))
y = RealDouble(2.0)
assert x.n(real=True) == y
x = 1 + 2*I
y = 1.0 + 2.0*I
assert x.n() == y
try:
from symengine import RealMPFR
x = sqrt(Integer(2))
y = RealMPFR('1.41421356237309504880169', 75)
assert x.n(75, real=True) == y
except ImportError:
x = sqrt(Integer(2))
raises(ValueError, lambda: (x.n(75, real=True)))
try:
from symengine import ComplexMPC
x = sqrt(Integer(2)) + 3*I
y = ComplexMPC('1.41421356237309504880169', '3.0', 75)
assert x.n(75) == y
except ImportError:
x = sqrt(Integer(2))
raises(ValueError, lambda: (x.n(75)))
def test_numpy_array_out_exceptions():
args, exprs, inp, check = _get_array()
assert len(args) == 3 and len(exprs) == 2
lmb = se.Lambdify(args, exprs)
all_right = np.empty(len(exprs))
lmb(inp, out=all_right)
too_short = np.empty(len(exprs) - 1)
raises(ValueError, lambda: (lmb(inp, out=too_short)))
wrong_dtype = np.empty(len(exprs), dtype=int)
raises(ValueError, lambda: (lmb(inp, out=wrong_dtype)))
read_only = np.empty(len(exprs))
read_only.flags['WRITEABLE'] = False
raises(ValueError, lambda: (lmb(inp, out=read_only)))
all_right_broadcast_C = np.empty((4, len(exprs)), order='C')
inp_bcast = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
lmb(np.array(inp_bcast), out=all_right_broadcast_C)
noncontig_broadcast = np.empty((4, len(exprs), 3)).transpose((1, 2, 0))
raises(ValueError, lambda: (lmb(inp_bcast, out=noncontig_broadcast)))
all_right_broadcast_F = np.empty((len(exprs), 4), order='F')
lmb.order = 'F'
lmb(np.array(np.array(inp_bcast).T), out=all_right_broadcast_F)
def test_n():
x = Symbol("x")
raises(RuntimeError, lambda: (x.n()))
x = 2 + I
raises(RuntimeError, lambda: (x.n(real=True)))
x = sqrt(Integer(4))
y = RealDouble(2.0)
assert x.n(real=True) == y
x = 1 + 2 * I
y = 1.0 + 2.0 * I
assert x.n() == y
def test_pysymbol():
a = MySymbol("hello", attr=1)
b = pickle.loads(pickle.dumps(a + 2)) - 2
try:
assert a == b
finally:
a._unsafe_reset()
b._unsafe_reset()
a = MySymbolBase("hello", attr=1)
try:
raises(NotImplementedError, lambda: pickle.dumps(a))
raises(NotImplementedError, lambda: pickle.dumps(a + 2))
finally:
a._unsafe_reset()
def test_add_matrix():
A = DenseMatrix(2, 2, [1, 2, 3, 4])
B = DenseMatrix(2, 2, [1, 0, 0, 1])
assert A.add_matrix(B) == DenseMatrix(2, 2, [2, 2, 3, 5])
a = Symbol("a")
b = Symbol("b")
c = Symbol("c")
d = Symbol("d")
A = DenseMatrix(2, 2, [a + b, a - b, a, b])
B = DenseMatrix(2, 2, [a - b, a + b, -a, b])
assert A.add_matrix(B) == DenseMatrix(2, 2, [2*a, 2*a, 0, 2*b])
assert A + B == DenseMatrix(2, 2, [2*a, 2*a, 0, 2*b])
C = DenseMatrix(1, 2, [a, b])
raises(ShapeError, lambda: A + C)
def test_add_matrix():
A = DenseMatrix(2, 2, [1, 2, 3, 4])
B = DenseMatrix(2, 2, [1, 0, 0, 1])
assert A.add_matrix(B) == DenseMatrix(2, 2, [2, 2, 3, 5])
a = Symbol("a")
b = Symbol("b")
c = Symbol("c")
d = Symbol("d")
A = DenseMatrix(2, 2, [a + b, a - b, a, b])
B = DenseMatrix(2, 2, [a - b, a + b, -a, b])
assert A.add_matrix(B) == DenseMatrix(2, 2, [2 * a, 2 * a, 0, 2 * b])
assert A + B == DenseMatrix(2, 2, [2 * a, 2 * a, 0, 2 * b])
C = DenseMatrix(1, 2, [a, b])
raises(ShapeError, lambda: A + C)
def test_row_col_del():
e = DenseMatrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])
raises(IndexError, lambda: e.row_del(5))
raises(IndexError, lambda: e.row_del(-5))
raises(IndexError, lambda: e.col_del(5))
raises(IndexError, lambda: e.col_del(-5))
assert e.row_del(-1) == DenseMatrix([[1, 2, 3], [4, 5, 6]])
assert e.col_del(-1) == DenseMatrix([[1, 2], [4, 5]])
e = DenseMatrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])
assert e.row_del(1) == DenseMatrix([[1, 2, 3], [7, 8, 9]])
assert e.col_del(1) == DenseMatrix([[1, 3], [7, 9]])
def test_Lambdify_Ndimensional_order_F():
args, nd_exprs_a, nd_exprs_b, f_a, f_b = _get_Ndim_args_exprs_funcs(order='F')
lmb4 = se.Lambdify(args, nd_exprs_a, nd_exprs_b, order='F')
nargs = len(args)
inp_extra_shape = (3, 5, 4)
inp_shape = (nargs,)+inp_extra_shape
inp4 = np.arange(reduce(mul, inp_shape)*1.0).reshape(inp_shape, order='F')
out4a, out4b = lmb4(inp4)
assert out4a.ndim == 7
assert out4a.shape == nd_exprs_a.shape + inp_extra_shape
assert out4b.ndim == 6
assert out4b.shape == nd_exprs_b.shape + inp_extra_shape
raises(ValueError, lambda: (lmb4(inp4.T)))
for b, c, d in np.ndindex(inp_extra_shape):
_x, _y = inp4[:, b, c, d]
for index in np.ndindex(*nd_exprs_a.shape):
assert np.isclose(out4a[index + (b, c, d)], f_a(index, _x, _y))
for index in np.ndindex(*nd_exprs_b.shape):
assert np.isclose(out4b[index + (b, c, d)], f_b(index, _x, _y))
def test_Float():
A = Float("1.23", precision = 53)
B = Float("1.23")
C = Float(A)
assert A == B == C
assert isinstance(A, Float)
assert isinstance(B, Float)
assert isinstance(C, Float)
assert isinstance(A, RealDouble)
assert isinstance(B, RealDouble)
assert isinstance(C, RealDouble)
raises(ValueError, lambda: Float("1.23", dps = 3, precision = 10))
raises(ValueError, lambda: Float(A, dps = 3, precision = 16))
if have_mpfr:
from symengine.sympy_compat import RealMPFR
A = Float("1.23", dps = 16)
B = Float("1.23", precision = 56)
assert A == B
assert isinstance(A, Float)
assert isinstance(B, Float)
assert isinstance(A, RealMPFR)
assert isinstance(B, RealMPFR)
A = Float(C, dps = 16)
assert A == B
assert isinstance(A, Float)
assert isinstance(A, RealMPFR)
A = Float(A, precision = 53)
assert A == C
assert isinstance(A, Float)
assert isinstance(A, RealDouble)
if not have_mpfr:
raises(ValueError, lambda: Float("1.23", precision = 58))
def test_immutablematrix():
A = ImmutableMatrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
assert A.shape == (3, 3)
assert A[1, 2] == 6
assert A[2, 2] == 9
assert A[1, :] == ImmutableMatrix([[4, 5, 6]])
assert A[:2, :2] == ImmutableMatrix([[1, 2], [4, 5]])
with raises(TypeError):
A[2, 2] = 5
X = DenseMatrix([[1, 2], [3, 4]])
assert X.as_immutable() == ImmutableMatrix([[1, 2], [3, 4]])
assert X.det() == -2
X = ImmutableMatrix(eye(3))
assert isinstance(X + A, ImmutableMatrix)
assert isinstance(X * A, ImmutableMatrix)
assert isinstance(X * 2, ImmutableMatrix)
assert isinstance(2 * X, ImmutableMatrix)
X = ImmutableMatrix([[1, 2], [3, 4]])
Y = ImmutableMatrix([[1], [0]])
assert type(X.LUsolve(Y)) == ImmutableMatrix
x = Symbol("x")
X = ImmutableMatrix([[1, 2], [3, 4]])
Y = ImmutableMatrix([[1, 2], [x, 4]])
assert Y.subs(x, 3) == X
assert Y.xreplace(x, 3) == X
X = ImmutableMatrix([[1, 2], [3, 4]])
Y = ImmutableMatrix([[5], [6]])
Z = X.row_join(Y)
assert isinstance(Z, ImmutableMatrix)
assert Z == ImmutableMatrix([[1, 2, 5], [3, 4, 6]])
X = ImmutableMatrix([[1, 2], [3, 4]])
Y = ImmutableMatrix([[5, 6]])
Z = X.col_join(Y)
assert isinstance(Z, ImmutableMatrix)
assert Z == ImmutableMatrix([[1, 2], [3, 4], [5, 6]])
# Operations of one immutable and one mutable matrix should give immutable result
X = ImmutableMatrix([1])
Y = DenseMatrix([1])
assert type(X + Y) == ImmutableMatrix
assert type(Y + X) == ImmutableMatrix
assert type(X * Y) == ImmutableMatrix
assert type(Y * X) == ImmutableMatrix
def test_mul_matrix():
A = DenseMatrix(2, 2, [1, 2, 3, 4])
B = DenseMatrix(2, 2, [1, 0, 0, 1])
assert A.mul_matrix(B) == A
a = Symbol("a")
b = Symbol("b")
c = Symbol("c")
d = Symbol("d")
A = DenseMatrix(2, 2, [a, b, c, d])
B = DenseMatrix(2, 2, [1, 0, 1, 0])
assert A.mul_matrix(B) == DenseMatrix(2, 2, [a + b, 0, c + d, 0])
assert A * B == DenseMatrix(2, 2, [a + b, 0, c + d, 0])
C = DenseMatrix(2, 3, [1, 2, 3, 2, 3, 4])
D = DenseMatrix(3, 2, [3, 4, 4, 5, 5, 6])
assert C.mul_matrix(D) == DenseMatrix(2, 2, [26, 32, 38, 47])
raises(ShapeError, lambda: A*D)
def test_mul_matrix():
A = DenseMatrix(2, 2, [1, 2, 3, 4])
B = DenseMatrix(2, 2, [1, 0, 0, 1])
assert A.mul_matrix(B) == A
a = Symbol("a")
b = Symbol("b")
c = Symbol("c")
d = Symbol("d")
A = DenseMatrix(2, 2, [a, b, c, d])
B = DenseMatrix(2, 2, [1, 0, 1, 0])
assert A.mul_matrix(B) == DenseMatrix(2, 2, [a + b, 0, c + d, 0])
assert A * B == DenseMatrix(2, 2, [a + b, 0, c + d, 0])
C = DenseMatrix(2, 3, [1, 2, 3, 2, 3, 4])
D = DenseMatrix(3, 2, [3, 4, 4, 5, 5, 6])
assert C.mul_matrix(D) == DenseMatrix(2, 2, [26, 32, 38, 47])
raises(ShapeError, lambda: A * D)
def test_DictBasic():
x, y, z = symbols("x y z")
d = DictBasic({x: 2, y: z})
assert str(d) == "{x: 2, y: z}" or str(d) == "{y: z, x: 2}"
assert d[x] == 2
raises(KeyError, lambda: d[2 * z])
if 2 * z in d:
assert False
d[2 * z] = x
assert d[2 * z] == x
if 2 * z not in d:
assert False
assert set(d.items()) == set([(2 * z, x), (x, Integer(2)), (y, z)])
del d[x]
assert set(d.keys()) == set([2 * z, y])
assert set(d.values()) == set([x, z])
e = y + sin(2 * z)
assert e.subs(d) == z + sin(x)
def test_DictBasic():
x, y, z = symbols("x y z")
d = DictBasic({x: 2, y: z})
assert str(d) == "{x: 2, y: z}" or str(d) == "{y: z, x: 2}"
assert d[x] == 2
raises(KeyError, lambda: d[2*z])
if 2*z in d:
assert False
d[2*z] = x
assert d[2*z] == x
if 2*z not in d:
assert False
assert set(d.items()) == set([(2*z, x), (x, Integer(2)), (y, z)])
del d[x]
assert set(d.keys()) == set([2*z, y])
assert set(d.values()) == set([x, z])
e = y + sin(2*z)
assert e.subs(d) == z + sin(x)
def test_sub():
A = DenseMatrix(2, 2, [1, 2, 3, 4])
B = DenseMatrix(2, 2, [0, -1, -2, -3])
a = Symbol("a")
assert A - B == DenseMatrix(2, 2, [1, 3, 5, 7])
C = DenseMatrix(2, 1, [1, 2])
raises(ShapeError, lambda: A - C)
raises(TypeError, lambda: A - 5)
raises(TypeError, lambda: 5 - A)
def test_sub():
A = DenseMatrix(2, 2, [1, 2, 3, 4])
B = DenseMatrix(2, 2, [0, -1, -2, -3])
a = Symbol("a")
assert A - B == DenseMatrix(2, 2, [1, 3, 5, 7])
C = DenseMatrix(2, 1, [1, 2])
raises(ShapeError, lambda: A - C)
raises(TypeError, lambda: A - 5)
raises(TypeError, lambda: 5 - A)
def test_get_item():
A = DenseMatrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])
assert A[5] == 6
assert A[-1] == 9
assert A[2, 2] == 9
assert A[-2, 2] == 6
assert A[1:2, 0] == DenseMatrix(1, 1, [4])
assert A[1:3, 0] == DenseMatrix(2, 1, [4, 7])
assert A[1:3, 0] == DenseMatrix(2, 1, [4, 7])
assert A[1:3, 1:] == DenseMatrix(2, 2, [5, 6, 8, 9])
assert A[1:3, :1] == DenseMatrix(2, 1, [4, 7])
assert A[0, 0:] == DenseMatrix(1, 3, [1, 2, 3])
assert A[2, :] == DenseMatrix(1, 3, [7, 8, 9])
assert A[:2, -2:] == DenseMatrix(2, 2, [2, 3, 5, 6])
assert A[1:, :3] == DenseMatrix(2, 3, [4, 5, 6, 7, 8, 9])
assert A[1:] == [2, 3, 4, 5, 6, 7, 8, 9]
assert A[-2:] == [8, 9]
assert A[[0, 2], 0] == DenseMatrix(2, 1, [1, 7])
assert A[[0, 2], [0]] == DenseMatrix(2, 1, [1, 7])
assert A[0, [0, 2]] == DenseMatrix(1, 2, [1, 3])
assert A[[0], [0, 2]] == DenseMatrix(1, 2, [1, 3])
raises(IndexError, lambda: A[-10])
raises(IndexError, lambda: A[9])
raises(IndexError, lambda: A[1:3, 3])
raises(IndexError, lambda: A[1:3, -4])
A = zeros(3, 4)
assert list(A[0, :]) == [0, 0, 0, 0]
assert list(A[:, 0]) == [0, 0, 0]
A = zeros(4, 3)
assert list(A[:, 0]) == [0, 0, 0, 0]
assert list(A[0, :]) == [0, 0, 0]
def test_derivative():
x = Symbol("x")
y = Symbol("y")
f = function_symbol("f", x)
assert f.diff(x) == function_symbol("f", x).diff(x)
assert f.diff(x).diff(x) == function_symbol("f", x).diff(x).diff(x)
assert f.diff(y) == 0
assert f.diff(x).args == (f, x)
assert f.diff(x).diff(x).args == (f, x, x)
assert f.diff(x, 0) == f
assert f.diff(x, 0) == Derivative(function_symbol("f", x), x, 0)
raises(ValueError, lambda: f.diff(0))
raises(ValueError, lambda: f.diff(x, 0, 0))
raises(ValueError, lambda: f.diff(x, y, 0, 0, x))
g = function_symbol("f", y)
assert g.diff(x) == 0
assert g.diff(y) == function_symbol("f", y).diff(y)
assert g.diff(y).diff(y) == function_symbol("f", y).diff(y).diff(y)
assert f - function_symbol("f", x) == 0
f = function_symbol("f", x, y)
assert f.diff(x).diff(y) == function_symbol("f", x, y).diff(x).diff(y)
assert f.diff(Symbol("z")) == 0
s = Derivative(function_symbol("f", x), x)
assert s.expr == function_symbol("f", x)
assert s.variables == (x, )
fxy = Function("f")(x, y)
g = Derivative(Function("f")(x, y), x, 2, y, 1)
assert g == fxy.diff(x, x, y)
assert g == fxy.diff(y, 1, x, 2)
assert g == fxy.diff(y, x, 2)
h = Derivative(Function("f")(x, y), x, 0, y, 1)
assert h == fxy.diff(x, 0, y)
assert h == fxy.diff(y, x, 0)
i = Derivative(Function("f")(x, y), x, 0, y, 1, x, 1)
assert i == fxy.diff(x, 0, y, x, 1)
assert i == fxy.diff(x, 0, y, x)
assert i == fxy.diff(y, x)
assert i == fxy.diff(y, 1, x, 1)
assert i == fxy.diff(y, 1, x)
def test_get():
A = DenseMatrix([[1, 2], [3, 4]])
assert A.get(0, 0) == 1
assert A.get(0, 1) == 2
assert A.get(1, 1) == 4
a = Symbol("a")
b = Symbol("b")
c = Symbol("c")
d = Symbol("d")
A = DenseMatrix(2, 2, [a, b, c, d])
assert A.get(0, 0) == a
assert A.get(1, 0) == c
assert A.get(1, 1) == d
assert A.get(-1, 0) == c
assert A.get(-1, -1) == d
raises(IndexError, lambda: A.get(2, 0))
raises(IndexError, lambda: A.get(0, 2))
raises(IndexError, lambda: A.get(-3, 0))
def test_get():
A = DenseMatrix([[1, 2], [3, 4]])
assert A.get(0, 0) == 1
assert A.get(0, 1) == 2
assert A.get(1, 1) == 4
a = Symbol("a")
b = Symbol("b")
c = Symbol("c")
d = Symbol("d")
A = DenseMatrix(2, 2, [a, b, c, d])
assert A.get(0, 0) == a
assert A.get(1, 0) == c
assert A.get(1, 1) == d
assert A.get(-1, 0) == c
assert A.get(-1, -1) == d
raises(IndexError, lambda: A.get(2, 0))
raises(IndexError, lambda: A.get(0, 2))
raises(IndexError, lambda: A.get(-3, 0))
def test_binomial_error():
raises(ArithmeticError, lambda: binomial(5, -1))
def test_args():
x = Symbol("x")
e = cos(x)
raises(TypeError, lambda: e.subs(x, 0, 3))
def test_factorial_error():
raises(ArithmeticError, lambda: factorial(-1))
def test_integer_string():
raises(TypeError, lambda: Integer("133"))
def test_eval_double2():
x = Symbol("x")
y = Symbol("y")
e = sin(x)**2 + cos(x)**2
raises(RuntimeError, lambda: (abs(eval_double(e) - 1) < 1e-9))
def test_arit3():
x = Symbol("x")
y = Symbol("y")
raises(TypeError, lambda: ("x"*x))
def test_mod_error():
raises(ZeroDivisionError, lambda: mod(2, 0))
def test_error3():
raises(SympifyError, lambda: sympify(" x "))
def test_lucas2_error():
raises(NotImplementedError, lambda: lucas2(-1))
def test_bigfloat_invalid():
raises(ValueError, lambda: Integer(13333333333333333.5))
def test_fibonacci_error():
raises(NotImplementedError, lambda: fibonacci(-3))
def test_quotient_mod_error():
raises(ZeroDivisionError, lambda: quotient_mod(1, 0))
def test_fibonacci2_error():
raises(NotImplementedError, lambda: fibonacci2(-1))
def test_sympify_error1a():
raises(SympifyError, lambda: sympify("if"))
def test_arit3():
x = Symbol("x")
y = Symbol("y")
raises(TypeError, lambda: ("x" * x))
def test_symbols():
x = Symbol('x')
y = Symbol('y')
z = Symbol('z')
assert symbols('x') == x
assert symbols('x ') == x
assert symbols(' x ') == x
assert symbols('x,') == (x,)
assert symbols('x, ') == (x,)
assert symbols('x ,') == (x,)
assert symbols('x , y') == (x, y)
assert symbols('x,y,z') == (x, y, z)
assert symbols('x y z') == (x, y, z)
assert symbols('x,y,z,') == (x, y, z)
assert symbols('x y z ') == (x, y, z)
xyz = Symbol('xyz')
abc = Symbol('abc')
assert symbols('xyz') == xyz
assert symbols('xyz,') == (xyz,)
assert symbols('xyz,abc') == (xyz, abc)
assert symbols(('xyz',)) == (xyz,)
assert symbols(('xyz,',)) == ((xyz,),)
assert symbols(('x,y,z,',)) == ((x, y, z),)
assert symbols(('xyz', 'abc')) == (xyz, abc)
assert symbols(('xyz,abc',)) == ((xyz, abc),)
assert symbols(('xyz,abc', 'x,y,z')) == ((xyz, abc), (x, y, z))
assert symbols(('x', 'y', 'z')) == (x, y, z)
assert symbols(['x', 'y', 'z']) == [x, y, z]
assert symbols(set(['x', 'y', 'z'])) == set([x, y, z])
raises(ValueError, lambda: symbols(''))
raises(ValueError, lambda: symbols(','))
raises(ValueError, lambda: symbols('x,,y,,z'))
raises(ValueError, lambda: symbols(('x', '', 'y', '', 'z')))
x0 = Symbol('x0')
x1 = Symbol('x1')
x2 = Symbol('x2')
y0 = Symbol('y0')
y1 = Symbol('y1')
assert symbols('x0:0') == ()
assert symbols('x0:1') == (x0,)
assert symbols('x0:2') == (x0, x1)
assert symbols('x0:3') == (x0, x1, x2)
assert symbols('x:0') == ()
assert symbols('x:1') == (x0,)
assert symbols('x:2') == (x0, x1)
assert symbols('x:3') == (x0, x1, x2)
assert symbols('x1:1') == ()
assert symbols('x1:2') == (x1,)
assert symbols('x1:3') == (x1, x2)
assert symbols('x1:3,x,y,z') == (x1, x2, x, y, z)
assert symbols('x:3,y:2') == (x0, x1, x2, y0, y1)
assert symbols(('x:3', 'y:2')) == ((x0, x1, x2), (y0, y1))
a = Symbol('a')
b = Symbol('b')
c = Symbol('c')
d = Symbol('d')
assert symbols('x:z') == (x, y, z)
assert symbols('a:d,x:z') == (a, b, c, d, x, y, z)
assert symbols(('a:d', 'x:z')) == ((a, b, c, d), (x, y, z))
aa = Symbol('aa')
ab = Symbol('ab')
ac = Symbol('ac')
ad = Symbol('ad')
assert symbols('aa:d') == (aa, ab, ac, ad)
assert symbols('aa:d,x:z') == (aa, ab, ac, ad, x, y, z)
assert symbols(('aa:d','x:z')) == ((aa, ab, ac, ad), (x, y, z))
def sym(s):
return str(symbols(s))
assert sym('a0:4') == '(a0, a1, a2, a3)'
assert sym('a2:4,b1:3') == '(a2, a3, b1, b2)'
assert sym('a1(2:4)') == '(a12, a13)'
assert sym(('a0:2.0:2')) == '(a0.0, a0.1, a1.0, a1.1)'
assert sym(('aa:cz')) == '(aaz, abz, acz)'
assert sym('aa:c0:2') == '(aa0, aa1, ab0, ab1, ac0, ac1)'
assert sym('aa:ba:b') == '(aaa, aab, aba, abb)'
assert sym('a:3b') == '(a0b, a1b, a2b)'
assert sym('a-1:3b') == '(a-1b, a-2b)'
assert sym('a:2\,:2' + chr(0)) == '(a0,0%s, a0,1%s, a1,0%s, a1,1%s)' % (
(chr(0),)*4)
assert sym('x(:a:3)') == '(x(a0), x(a1), x(a2))'
assert sym('x(:c):1') == '(xa0, xb0, xc0)'
assert sym('x((:a)):3') == '(x(a)0, x(a)1, x(a)2)'
assert sym('x(:a:3') == '(x(a0, x(a1, x(a2)'
assert sym(':2') == '(0, 1)'
assert sym(':b') == '(a, b)'
assert sym(':b:2') == '(a0, a1, b0, b1)'
assert sym(':2:2') == '(00, 01, 10, 11)'
assert sym(':b:b') == '(aa, ab, ba, bb)'
raises(ValueError, lambda: symbols(':'))
raises(ValueError, lambda: symbols('a:'))
raises(ValueError, lambda: symbols('::'))
raises(ValueError, lambda: symbols('a::'))
raises(ValueError, lambda: symbols(':a:'))
raises(ValueError, lambda: symbols('::a'))