454 lines
15 KiB
Python
454 lines
15 KiB
Python
import collections.abc
|
|
|
|
import numpy as np
|
|
from numpy import matrix, asmatrix, bmat
|
|
from numpy.testing import (
|
|
assert_, assert_equal, assert_almost_equal, assert_array_equal,
|
|
assert_array_almost_equal, assert_raises
|
|
)
|
|
from numpy.linalg import matrix_power
|
|
from numpy.matrixlib import mat
|
|
|
|
class TestCtor:
|
|
def test_basic(self):
|
|
A = np.array([[1, 2], [3, 4]])
|
|
mA = matrix(A)
|
|
assert_(np.all(mA.A == A))
|
|
|
|
B = bmat("A,A;A,A")
|
|
C = bmat([[A, A], [A, A]])
|
|
D = np.array([[1, 2, 1, 2],
|
|
[3, 4, 3, 4],
|
|
[1, 2, 1, 2],
|
|
[3, 4, 3, 4]])
|
|
assert_(np.all(B.A == D))
|
|
assert_(np.all(C.A == D))
|
|
|
|
E = np.array([[5, 6], [7, 8]])
|
|
AEresult = matrix([[1, 2, 5, 6], [3, 4, 7, 8]])
|
|
assert_(np.all(bmat([A, E]) == AEresult))
|
|
|
|
vec = np.arange(5)
|
|
mvec = matrix(vec)
|
|
assert_(mvec.shape == (1, 5))
|
|
|
|
def test_exceptions(self):
|
|
# Check for ValueError when called with invalid string data.
|
|
assert_raises(ValueError, matrix, "invalid")
|
|
|
|
def test_bmat_nondefault_str(self):
|
|
A = np.array([[1, 2], [3, 4]])
|
|
B = np.array([[5, 6], [7, 8]])
|
|
Aresult = np.array([[1, 2, 1, 2],
|
|
[3, 4, 3, 4],
|
|
[1, 2, 1, 2],
|
|
[3, 4, 3, 4]])
|
|
mixresult = np.array([[1, 2, 5, 6],
|
|
[3, 4, 7, 8],
|
|
[5, 6, 1, 2],
|
|
[7, 8, 3, 4]])
|
|
assert_(np.all(bmat("A,A;A,A") == Aresult))
|
|
assert_(np.all(bmat("A,A;A,A", ldict={'A':B}) == Aresult))
|
|
assert_raises(TypeError, bmat, "A,A;A,A", gdict={'A':B})
|
|
assert_(
|
|
np.all(bmat("A,A;A,A", ldict={'A':A}, gdict={'A':B}) == Aresult))
|
|
b2 = bmat("A,B;C,D", ldict={'A':A,'B':B}, gdict={'C':B,'D':A})
|
|
assert_(np.all(b2 == mixresult))
|
|
|
|
|
|
class TestProperties:
|
|
def test_sum(self):
|
|
"""Test whether matrix.sum(axis=1) preserves orientation.
|
|
Fails in NumPy <= 0.9.6.2127.
|
|
"""
|
|
M = matrix([[1, 2, 0, 0],
|
|
[3, 4, 0, 0],
|
|
[1, 2, 1, 2],
|
|
[3, 4, 3, 4]])
|
|
sum0 = matrix([8, 12, 4, 6])
|
|
sum1 = matrix([3, 7, 6, 14]).T
|
|
sumall = 30
|
|
assert_array_equal(sum0, M.sum(axis=0))
|
|
assert_array_equal(sum1, M.sum(axis=1))
|
|
assert_equal(sumall, M.sum())
|
|
|
|
assert_array_equal(sum0, np.sum(M, axis=0))
|
|
assert_array_equal(sum1, np.sum(M, axis=1))
|
|
assert_equal(sumall, np.sum(M))
|
|
|
|
def test_prod(self):
|
|
x = matrix([[1, 2, 3], [4, 5, 6]])
|
|
assert_equal(x.prod(), 720)
|
|
assert_equal(x.prod(0), matrix([[4, 10, 18]]))
|
|
assert_equal(x.prod(1), matrix([[6], [120]]))
|
|
|
|
assert_equal(np.prod(x), 720)
|
|
assert_equal(np.prod(x, axis=0), matrix([[4, 10, 18]]))
|
|
assert_equal(np.prod(x, axis=1), matrix([[6], [120]]))
|
|
|
|
y = matrix([0, 1, 3])
|
|
assert_(y.prod() == 0)
|
|
|
|
def test_max(self):
|
|
x = matrix([[1, 2, 3], [4, 5, 6]])
|
|
assert_equal(x.max(), 6)
|
|
assert_equal(x.max(0), matrix([[4, 5, 6]]))
|
|
assert_equal(x.max(1), matrix([[3], [6]]))
|
|
|
|
assert_equal(np.max(x), 6)
|
|
assert_equal(np.max(x, axis=0), matrix([[4, 5, 6]]))
|
|
assert_equal(np.max(x, axis=1), matrix([[3], [6]]))
|
|
|
|
def test_min(self):
|
|
x = matrix([[1, 2, 3], [4, 5, 6]])
|
|
assert_equal(x.min(), 1)
|
|
assert_equal(x.min(0), matrix([[1, 2, 3]]))
|
|
assert_equal(x.min(1), matrix([[1], [4]]))
|
|
|
|
assert_equal(np.min(x), 1)
|
|
assert_equal(np.min(x, axis=0), matrix([[1, 2, 3]]))
|
|
assert_equal(np.min(x, axis=1), matrix([[1], [4]]))
|
|
|
|
def test_ptp(self):
|
|
x = np.arange(4).reshape((2, 2))
|
|
assert_(x.ptp() == 3)
|
|
assert_(np.all(x.ptp(0) == np.array([2, 2])))
|
|
assert_(np.all(x.ptp(1) == np.array([1, 1])))
|
|
|
|
def test_var(self):
|
|
x = np.arange(9).reshape((3, 3))
|
|
mx = x.view(np.matrix)
|
|
assert_equal(x.var(ddof=0), mx.var(ddof=0))
|
|
assert_equal(x.var(ddof=1), mx.var(ddof=1))
|
|
|
|
def test_basic(self):
|
|
import numpy.linalg as linalg
|
|
|
|
A = np.array([[1., 2.],
|
|
[3., 4.]])
|
|
mA = matrix(A)
|
|
assert_(np.allclose(linalg.inv(A), mA.I))
|
|
assert_(np.all(np.array(np.transpose(A) == mA.T)))
|
|
assert_(np.all(np.array(np.transpose(A) == mA.H)))
|
|
assert_(np.all(A == mA.A))
|
|
|
|
B = A + 2j*A
|
|
mB = matrix(B)
|
|
assert_(np.allclose(linalg.inv(B), mB.I))
|
|
assert_(np.all(np.array(np.transpose(B) == mB.T)))
|
|
assert_(np.all(np.array(np.transpose(B).conj() == mB.H)))
|
|
|
|
def test_pinv(self):
|
|
x = matrix(np.arange(6).reshape(2, 3))
|
|
xpinv = matrix([[-0.77777778, 0.27777778],
|
|
[-0.11111111, 0.11111111],
|
|
[ 0.55555556, -0.05555556]])
|
|
assert_almost_equal(x.I, xpinv)
|
|
|
|
def test_comparisons(self):
|
|
A = np.arange(100).reshape(10, 10)
|
|
mA = matrix(A)
|
|
mB = matrix(A) + 0.1
|
|
assert_(np.all(mB == A+0.1))
|
|
assert_(np.all(mB == matrix(A+0.1)))
|
|
assert_(not np.any(mB == matrix(A-0.1)))
|
|
assert_(np.all(mA < mB))
|
|
assert_(np.all(mA <= mB))
|
|
assert_(np.all(mA <= mA))
|
|
assert_(not np.any(mA < mA))
|
|
|
|
assert_(not np.any(mB < mA))
|
|
assert_(np.all(mB >= mA))
|
|
assert_(np.all(mB >= mB))
|
|
assert_(not np.any(mB > mB))
|
|
|
|
assert_(np.all(mA == mA))
|
|
assert_(not np.any(mA == mB))
|
|
assert_(np.all(mB != mA))
|
|
|
|
assert_(not np.all(abs(mA) > 0))
|
|
assert_(np.all(abs(mB > 0)))
|
|
|
|
def test_asmatrix(self):
|
|
A = np.arange(100).reshape(10, 10)
|
|
mA = asmatrix(A)
|
|
A[0, 0] = -10
|
|
assert_(A[0, 0] == mA[0, 0])
|
|
|
|
def test_noaxis(self):
|
|
A = matrix([[1, 0], [0, 1]])
|
|
assert_(A.sum() == matrix(2))
|
|
assert_(A.mean() == matrix(0.5))
|
|
|
|
def test_repr(self):
|
|
A = matrix([[1, 0], [0, 1]])
|
|
assert_(repr(A) == "matrix([[1, 0],\n [0, 1]])")
|
|
|
|
def test_make_bool_matrix_from_str(self):
|
|
A = matrix('True; True; False')
|
|
B = matrix([[True], [True], [False]])
|
|
assert_array_equal(A, B)
|
|
|
|
class TestCasting:
|
|
def test_basic(self):
|
|
A = np.arange(100).reshape(10, 10)
|
|
mA = matrix(A)
|
|
|
|
mB = mA.copy()
|
|
O = np.ones((10, 10), np.float64) * 0.1
|
|
mB = mB + O
|
|
assert_(mB.dtype.type == np.float64)
|
|
assert_(np.all(mA != mB))
|
|
assert_(np.all(mB == mA+0.1))
|
|
|
|
mC = mA.copy()
|
|
O = np.ones((10, 10), np.complex128)
|
|
mC = mC * O
|
|
assert_(mC.dtype.type == np.complex128)
|
|
assert_(np.all(mA != mB))
|
|
|
|
|
|
class TestAlgebra:
|
|
def test_basic(self):
|
|
import numpy.linalg as linalg
|
|
|
|
A = np.array([[1., 2.], [3., 4.]])
|
|
mA = matrix(A)
|
|
|
|
B = np.identity(2)
|
|
for i in range(6):
|
|
assert_(np.allclose((mA ** i).A, B))
|
|
B = np.dot(B, A)
|
|
|
|
Ainv = linalg.inv(A)
|
|
B = np.identity(2)
|
|
for i in range(6):
|
|
assert_(np.allclose((mA ** -i).A, B))
|
|
B = np.dot(B, Ainv)
|
|
|
|
assert_(np.allclose((mA * mA).A, np.dot(A, A)))
|
|
assert_(np.allclose((mA + mA).A, (A + A)))
|
|
assert_(np.allclose((3*mA).A, (3*A)))
|
|
|
|
mA2 = matrix(A)
|
|
mA2 *= 3
|
|
assert_(np.allclose(mA2.A, 3*A))
|
|
|
|
def test_pow(self):
|
|
"""Test raising a matrix to an integer power works as expected."""
|
|
m = matrix("1. 2.; 3. 4.")
|
|
m2 = m.copy()
|
|
m2 **= 2
|
|
mi = m.copy()
|
|
mi **= -1
|
|
m4 = m2.copy()
|
|
m4 **= 2
|
|
assert_array_almost_equal(m2, m**2)
|
|
assert_array_almost_equal(m4, np.dot(m2, m2))
|
|
assert_array_almost_equal(np.dot(mi, m), np.eye(2))
|
|
|
|
def test_scalar_type_pow(self):
|
|
m = matrix([[1, 2], [3, 4]])
|
|
for scalar_t in [np.int8, np.uint8]:
|
|
two = scalar_t(2)
|
|
assert_array_almost_equal(m ** 2, m ** two)
|
|
|
|
def test_notimplemented(self):
|
|
'''Check that 'not implemented' operations produce a failure.'''
|
|
A = matrix([[1., 2.],
|
|
[3., 4.]])
|
|
|
|
# __rpow__
|
|
with assert_raises(TypeError):
|
|
1.0**A
|
|
|
|
# __mul__ with something not a list, ndarray, tuple, or scalar
|
|
with assert_raises(TypeError):
|
|
A*object()
|
|
|
|
|
|
class TestMatrixReturn:
|
|
def test_instance_methods(self):
|
|
a = matrix([1.0], dtype='f8')
|
|
methodargs = {
|
|
'astype': ('intc',),
|
|
'clip': (0.0, 1.0),
|
|
'compress': ([1],),
|
|
'repeat': (1,),
|
|
'reshape': (1,),
|
|
'swapaxes': (0, 0),
|
|
'dot': np.array([1.0]),
|
|
}
|
|
excluded_methods = [
|
|
'argmin', 'choose', 'dump', 'dumps', 'fill', 'getfield',
|
|
'getA', 'getA1', 'item', 'nonzero', 'put', 'putmask', 'resize',
|
|
'searchsorted', 'setflags', 'setfield', 'sort',
|
|
'partition', 'argpartition',
|
|
'take', 'tofile', 'tolist', 'tostring', 'tobytes', 'all', 'any',
|
|
'sum', 'argmax', 'argmin', 'min', 'max', 'mean', 'var', 'ptp',
|
|
'prod', 'std', 'ctypes', 'itemset',
|
|
]
|
|
for attrib in dir(a):
|
|
if attrib.startswith('_') or attrib in excluded_methods:
|
|
continue
|
|
f = getattr(a, attrib)
|
|
if isinstance(f, collections.abc.Callable):
|
|
# reset contents of a
|
|
a.astype('f8')
|
|
a.fill(1.0)
|
|
if attrib in methodargs:
|
|
args = methodargs[attrib]
|
|
else:
|
|
args = ()
|
|
b = f(*args)
|
|
assert_(type(b) is matrix, "%s" % attrib)
|
|
assert_(type(a.real) is matrix)
|
|
assert_(type(a.imag) is matrix)
|
|
c, d = matrix([0.0]).nonzero()
|
|
assert_(type(c) is np.ndarray)
|
|
assert_(type(d) is np.ndarray)
|
|
|
|
|
|
class TestIndexing:
|
|
def test_basic(self):
|
|
x = asmatrix(np.zeros((3, 2), float))
|
|
y = np.zeros((3, 1), float)
|
|
y[:, 0] = [0.8, 0.2, 0.3]
|
|
x[:, 1] = y > 0.5
|
|
assert_equal(x, [[0, 1], [0, 0], [0, 0]])
|
|
|
|
|
|
class TestNewScalarIndexing:
|
|
a = matrix([[1, 2], [3, 4]])
|
|
|
|
def test_dimesions(self):
|
|
a = self.a
|
|
x = a[0]
|
|
assert_equal(x.ndim, 2)
|
|
|
|
def test_array_from_matrix_list(self):
|
|
a = self.a
|
|
x = np.array([a, a])
|
|
assert_equal(x.shape, [2, 2, 2])
|
|
|
|
def test_array_to_list(self):
|
|
a = self.a
|
|
assert_equal(a.tolist(), [[1, 2], [3, 4]])
|
|
|
|
def test_fancy_indexing(self):
|
|
a = self.a
|
|
x = a[1, [0, 1, 0]]
|
|
assert_(isinstance(x, matrix))
|
|
assert_equal(x, matrix([[3, 4, 3]]))
|
|
x = a[[1, 0]]
|
|
assert_(isinstance(x, matrix))
|
|
assert_equal(x, matrix([[3, 4], [1, 2]]))
|
|
x = a[[[1], [0]], [[1, 0], [0, 1]]]
|
|
assert_(isinstance(x, matrix))
|
|
assert_equal(x, matrix([[4, 3], [1, 2]]))
|
|
|
|
def test_matrix_element(self):
|
|
x = matrix([[1, 2, 3], [4, 5, 6]])
|
|
assert_equal(x[0][0], matrix([[1, 2, 3]]))
|
|
assert_equal(x[0][0].shape, (1, 3))
|
|
assert_equal(x[0].shape, (1, 3))
|
|
assert_equal(x[:, 0].shape, (2, 1))
|
|
|
|
x = matrix(0)
|
|
assert_equal(x[0, 0], 0)
|
|
assert_equal(x[0], 0)
|
|
assert_equal(x[:, 0].shape, x.shape)
|
|
|
|
def test_scalar_indexing(self):
|
|
x = asmatrix(np.zeros((3, 2), float))
|
|
assert_equal(x[0, 0], x[0][0])
|
|
|
|
def test_row_column_indexing(self):
|
|
x = asmatrix(np.eye(2))
|
|
assert_array_equal(x[0,:], [[1, 0]])
|
|
assert_array_equal(x[1,:], [[0, 1]])
|
|
assert_array_equal(x[:, 0], [[1], [0]])
|
|
assert_array_equal(x[:, 1], [[0], [1]])
|
|
|
|
def test_boolean_indexing(self):
|
|
A = np.arange(6)
|
|
A.shape = (3, 2)
|
|
x = asmatrix(A)
|
|
assert_array_equal(x[:, np.array([True, False])], x[:, 0])
|
|
assert_array_equal(x[np.array([True, False, False]),:], x[0,:])
|
|
|
|
def test_list_indexing(self):
|
|
A = np.arange(6)
|
|
A.shape = (3, 2)
|
|
x = asmatrix(A)
|
|
assert_array_equal(x[:, [1, 0]], x[:, ::-1])
|
|
assert_array_equal(x[[2, 1, 0],:], x[::-1,:])
|
|
|
|
|
|
class TestPower:
|
|
def test_returntype(self):
|
|
a = np.array([[0, 1], [0, 0]])
|
|
assert_(type(matrix_power(a, 2)) is np.ndarray)
|
|
a = mat(a)
|
|
assert_(type(matrix_power(a, 2)) is matrix)
|
|
|
|
def test_list(self):
|
|
assert_array_equal(matrix_power([[0, 1], [0, 0]], 2), [[0, 0], [0, 0]])
|
|
|
|
|
|
class TestShape:
|
|
|
|
a = np.array([[1], [2]])
|
|
m = matrix([[1], [2]])
|
|
|
|
def test_shape(self):
|
|
assert_equal(self.a.shape, (2, 1))
|
|
assert_equal(self.m.shape, (2, 1))
|
|
|
|
def test_numpy_ravel(self):
|
|
assert_equal(np.ravel(self.a).shape, (2,))
|
|
assert_equal(np.ravel(self.m).shape, (2,))
|
|
|
|
def test_member_ravel(self):
|
|
assert_equal(self.a.ravel().shape, (2,))
|
|
assert_equal(self.m.ravel().shape, (1, 2))
|
|
|
|
def test_member_flatten(self):
|
|
assert_equal(self.a.flatten().shape, (2,))
|
|
assert_equal(self.m.flatten().shape, (1, 2))
|
|
|
|
def test_numpy_ravel_order(self):
|
|
x = np.array([[1, 2, 3], [4, 5, 6]])
|
|
assert_equal(np.ravel(x), [1, 2, 3, 4, 5, 6])
|
|
assert_equal(np.ravel(x, order='F'), [1, 4, 2, 5, 3, 6])
|
|
assert_equal(np.ravel(x.T), [1, 4, 2, 5, 3, 6])
|
|
assert_equal(np.ravel(x.T, order='A'), [1, 2, 3, 4, 5, 6])
|
|
x = matrix([[1, 2, 3], [4, 5, 6]])
|
|
assert_equal(np.ravel(x), [1, 2, 3, 4, 5, 6])
|
|
assert_equal(np.ravel(x, order='F'), [1, 4, 2, 5, 3, 6])
|
|
assert_equal(np.ravel(x.T), [1, 4, 2, 5, 3, 6])
|
|
assert_equal(np.ravel(x.T, order='A'), [1, 2, 3, 4, 5, 6])
|
|
|
|
def test_matrix_ravel_order(self):
|
|
x = matrix([[1, 2, 3], [4, 5, 6]])
|
|
assert_equal(x.ravel(), [[1, 2, 3, 4, 5, 6]])
|
|
assert_equal(x.ravel(order='F'), [[1, 4, 2, 5, 3, 6]])
|
|
assert_equal(x.T.ravel(), [[1, 4, 2, 5, 3, 6]])
|
|
assert_equal(x.T.ravel(order='A'), [[1, 2, 3, 4, 5, 6]])
|
|
|
|
def test_array_memory_sharing(self):
|
|
assert_(np.may_share_memory(self.a, self.a.ravel()))
|
|
assert_(not np.may_share_memory(self.a, self.a.flatten()))
|
|
|
|
def test_matrix_memory_sharing(self):
|
|
assert_(np.may_share_memory(self.m, self.m.ravel()))
|
|
assert_(not np.may_share_memory(self.m, self.m.flatten()))
|
|
|
|
def test_expand_dims_matrix(self):
|
|
# matrices are always 2d - so expand_dims only makes sense when the
|
|
# type is changed away from matrix.
|
|
a = np.arange(10).reshape((2, 5)).view(np.matrix)
|
|
expanded = np.expand_dims(a, axis=1)
|
|
assert_equal(expanded.ndim, 3)
|
|
assert_(not isinstance(expanded, np.matrix))
|