numpy 2.4.1__pp311-pypy311_pp73-macosx_14_0_arm64.whl

numpy/matrixlib/defmatrix.pyi

@@ -0,0 +1,218 @@
+from _typeshed import Incomplete
+from collections.abc import Mapping, Sequence
+from types import EllipsisType
+from typing import Any, ClassVar, Literal as L, Self, SupportsIndex, TypeAlias, overload
+from typing_extensions import TypeVar
+
+import numpy as np
+from numpy._typing import (
+    ArrayLike,
+    DTypeLike,
+    NDArray,
+    _AnyShape,
+    _ArrayLikeInt_co,
+    _NestedSequence,
+    _ShapeLike,
+)
+
+__all__ = ["asmatrix", "bmat", "matrix"]
+
+_T = TypeVar("_T")
+_ArrayT = TypeVar("_ArrayT", bound=np.ndarray)
+_BoolOrIntArrayT = TypeVar("_BoolOrIntArrayT", bound=NDArray[np.integer | np.bool])
+_ScalarT = TypeVar("_ScalarT", bound=np.generic)
+_ShapeT_co = TypeVar("_ShapeT_co", bound=_2D, default=_2D, covariant=True)
+_DTypeT_co = TypeVar("_DTypeT_co", bound=np.dtype, default=np.dtype, covariant=True)
+
+_2D: TypeAlias = tuple[int, int]
+_Matrix: TypeAlias = matrix[_2D, np.dtype[_ScalarT]]
+_ToIndex1: TypeAlias = slice | EllipsisType | NDArray[np.integer | np.bool] | _NestedSequence[int] | None
+_ToIndex2: TypeAlias = tuple[_ToIndex1, _ToIndex1 | SupportsIndex] | tuple[_ToIndex1 | SupportsIndex, _ToIndex1]
+
+class matrix(np.ndarray[_ShapeT_co, _DTypeT_co]):
+    __array_priority__: ClassVar[float] = 10.0  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    def __new__(
+        subtype,  # pyright: ignore[reportSelfClsParameterName]
+        data: ArrayLike,
+        dtype: DTypeLike | None = None,
+        copy: bool = True,
+    ) -> _Matrix[Incomplete]: ...
+
+    #
+    @overload  # type: ignore[override]
+    def __getitem__(
+        self, key: SupportsIndex | _ArrayLikeInt_co | tuple[SupportsIndex | _ArrayLikeInt_co, ...], /
+    ) -> Incomplete: ...
+    @overload
+    def __getitem__(self, key: _ToIndex1 | _ToIndex2, /) -> matrix[_2D, _DTypeT_co]: ...
+    @overload
+    def __getitem__(self: _Matrix[np.void], key: str, /) -> _Matrix[Incomplete]: ...
+    @overload
+    def __getitem__(self: _Matrix[np.void], key: list[str], /) -> matrix[_2D, _DTypeT_co]: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    #
+    def __mul__(self, other: ArrayLike, /) -> _Matrix[Incomplete]: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    def __rmul__(self, other: ArrayLike, /) -> _Matrix[Incomplete]: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    #
+    def __pow__(self, other: ArrayLike, /) -> _Matrix[Incomplete]: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    def __rpow__(self, other: ArrayLike, /) -> _Matrix[Incomplete]: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # keep in sync with `prod` and `mean`
+    @overload  # type: ignore[override]
+    def sum(self, axis: None = None, dtype: DTypeLike | None = None, out: None = None) -> Incomplete: ...
+    @overload
+    def sum(self, axis: _ShapeLike, dtype: DTypeLike | None = None, out: None = None) -> _Matrix[Incomplete]: ...
+    @overload
+    def sum(self, axis: _ShapeLike | None, dtype: DTypeLike | None, out: _ArrayT) -> _ArrayT: ...
+    @overload
+    def sum(self, axis: _ShapeLike | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT) -> _ArrayT: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # keep in sync with `sum` and `mean`
+    @overload  # type: ignore[override]
+    def prod(self, axis: None = None, dtype: DTypeLike | None = None, out: None = None) -> Incomplete: ...
+    @overload
+    def prod(self, axis: _ShapeLike, dtype: DTypeLike | None = None, out: None = None) -> _Matrix[Incomplete]: ...
+    @overload
+    def prod(self, axis: _ShapeLike | None, dtype: DTypeLike | None, out: _ArrayT) -> _ArrayT: ...
+    @overload
+    def prod(self, axis: _ShapeLike | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT) -> _ArrayT: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # keep in sync with `sum` and `prod`
+    @overload  # type: ignore[override]
+    def mean(self, axis: None = None, dtype: DTypeLike | None = None, out: None = None) -> Incomplete: ...
+    @overload
+    def mean(self, axis: _ShapeLike, dtype: DTypeLike | None = None, out: None = None) -> _Matrix[Incomplete]: ...
+    @overload
+    def mean(self, axis: _ShapeLike | None, dtype: DTypeLike | None, out: _ArrayT) -> _ArrayT: ...
+    @overload
+    def mean(self, axis: _ShapeLike | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT) -> _ArrayT: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # keep in sync with `var`
+    @overload  # type: ignore[override]
+    def std(self, axis: None = None, dtype: DTypeLike | None = None, out: None = None, ddof: float = 0) -> Incomplete: ...
+    @overload
+    def std(self, axis: _ShapeLike, dtype: DTypeLike | None = None, out: None = None, ddof: float = 0) -> _Matrix[Incomplete]: ...
+    @overload
+    def std(self, axis: _ShapeLike | None, dtype: DTypeLike | None, out: _ArrayT, ddof: float = 0) -> _ArrayT: ...
+    @overload
+    def std(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, axis: _ShapeLike | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT, ddof: float = 0
+    ) -> _ArrayT: ...
+
+    # keep in sync with `std`
+    @overload  # type: ignore[override]
+    def var(self, axis: None = None, dtype: DTypeLike | None = None, out: None = None, ddof: float = 0) -> Incomplete: ...
+    @overload
+    def var(self, axis: _ShapeLike, dtype: DTypeLike | None = None, out: None = None, ddof: float = 0) -> _Matrix[Incomplete]: ...
+    @overload
+    def var(self, axis: _ShapeLike | None, dtype: DTypeLike | None, out: _ArrayT, ddof: float = 0) -> _ArrayT: ...
+    @overload
+    def var(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, axis: _ShapeLike | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT, ddof: float = 0
+    ) -> _ArrayT: ...
+
+    # keep in sync with `all`
+    @overload  # type: ignore[override]
+    def any(self, axis: None = None, out: None = None) -> np.bool: ...
+    @overload
+    def any(self, axis: _ShapeLike, out: None = None) -> _Matrix[np.bool]: ...
+    @overload
+    def any(self, axis: _ShapeLike | None, out: _ArrayT) -> _ArrayT: ...
+    @overload
+    def any(self, axis: _ShapeLike | None = None, *, out: _ArrayT) -> _ArrayT: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # keep in sync with `any`
+    @overload  # type: ignore[override]
+    def all(self, axis: None = None, out: None = None) -> np.bool: ...
+    @overload
+    def all(self, axis: _ShapeLike, out: None = None) -> _Matrix[np.bool]: ...
+    @overload
+    def all(self, axis: _ShapeLike | None, out: _ArrayT) -> _ArrayT: ...
+    @overload
+    def all(self, axis: _ShapeLike | None = None, *, out: _ArrayT) -> _ArrayT: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # keep in sync with `min` and `ptp`
+    @overload  # type: ignore[override]
+    def max(self: NDArray[_ScalarT], axis: None = None, out: None = None) -> _ScalarT: ...
+    @overload
+    def max(self, axis: _ShapeLike, out: None = None) -> matrix[_2D, _DTypeT_co]: ...
+    @overload
+    def max(self, axis: _ShapeLike | None, out: _ArrayT) -> _ArrayT: ...
+    @overload
+    def max(self, axis: _ShapeLike | None = None, *, out: _ArrayT) -> _ArrayT: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # keep in sync with `max` and `ptp`
+    @overload  # type: ignore[override]
+    def min(self: NDArray[_ScalarT], axis: None = None, out: None = None) -> _ScalarT: ...
+    @overload
+    def min(self, axis: _ShapeLike, out: None = None) -> matrix[_2D, _DTypeT_co]: ...
+    @overload
+    def min(self, axis: _ShapeLike | None, out: _ArrayT) -> _ArrayT: ...
+    @overload
+    def min(self, axis: _ShapeLike | None = None, *, out: _ArrayT) -> _ArrayT: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # keep in sync with `max` and `min`
+    @overload
+    def ptp(self: NDArray[_ScalarT], axis: None = None, out: None = None) -> _ScalarT: ...
+    @overload
+    def ptp(self, axis: _ShapeLike, out: None = None) -> matrix[_2D, _DTypeT_co]: ...
+    @overload
+    def ptp(self, axis: _ShapeLike | None, out: _ArrayT) -> _ArrayT: ...
+    @overload
+    def ptp(self, axis: _ShapeLike | None = None, *, out: _ArrayT) -> _ArrayT: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # keep in sync with `argmin`
+    @overload  # type: ignore[override]
+    def argmax(self: NDArray[_ScalarT], axis: None = None, out: None = None) -> np.intp: ...
+    @overload
+    def argmax(self, axis: _ShapeLike, out: None = None) -> _Matrix[np.intp]: ...
+    @overload
+    def argmax(self, axis: _ShapeLike | None, out: _BoolOrIntArrayT) -> _BoolOrIntArrayT: ...
+    @overload
+    def argmax(self, axis: _ShapeLike | None = None, *, out: _BoolOrIntArrayT) -> _BoolOrIntArrayT: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # keep in sync with `argmax`
+    @overload  # type: ignore[override]
+    def argmin(self: NDArray[_ScalarT], axis: None = None, out: None = None) -> np.intp: ...
+    @overload
+    def argmin(self, axis: _ShapeLike, out: None = None) -> _Matrix[np.intp]: ...
+    @overload
+    def argmin(self, axis: _ShapeLike | None, out: _BoolOrIntArrayT) -> _BoolOrIntArrayT: ...
+    @overload
+    def argmin(self, axis: _ShapeLike | None = None, *, out: _BoolOrIntArrayT) -> _BoolOrIntArrayT: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # the second overload handles the (rare) case that the matrix is not 2-d
+    @overload
+    def tolist(self: _Matrix[np.generic[_T]]) -> list[list[_T]]: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+    @overload
+    def tolist(self) -> Incomplete: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # these three methods will at least return a `2-d` array of shape (1, n)
+    def squeeze(self, /, axis: _ShapeLike | None = None) -> matrix[_2D, _DTypeT_co]: ...
+    def ravel(self, /, order: L["K", "A", "C", "F"] | None = "C") -> matrix[_2D, _DTypeT_co]: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    def flatten(self, /, order: L["K", "A", "C", "F"] | None = "C") -> matrix[_2D, _DTypeT_co]: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # matrix.T is inherited from _ScalarOrArrayCommon
+    def getT(self) -> Self: ...
+    @property
+    def I(self) -> _Matrix[Incomplete]: ...  # noqa: E743
+    def getI(self) -> _Matrix[Incomplete]: ...
+    @property
+    def A(self) -> np.ndarray[_2D, _DTypeT_co]: ...
+    def getA(self) -> np.ndarray[_2D, _DTypeT_co]: ...
+    @property
+    def A1(self) -> np.ndarray[_AnyShape, _DTypeT_co]: ...
+    def getA1(self) -> np.ndarray[_AnyShape, _DTypeT_co]: ...
+    @property
+    def H(self) -> matrix[_2D, _DTypeT_co]: ...
+    def getH(self) -> matrix[_2D, _DTypeT_co]: ...
+
+def bmat(
+    obj: str | Sequence[ArrayLike] | NDArray[Any],
+    ldict: Mapping[str, Any] | None = None,
+    gdict: Mapping[str, Any] | None = None,
+) -> _Matrix[Incomplete]: ...
+
+def asmatrix(data: ArrayLike, dtype: DTypeLike | None = None) -> _Matrix[Incomplete]: ...

numpy/matrixlib/tests/test_defmatrix.py

@@ -0,0 +1,455 @@
+import collections.abc
+
+import numpy as np
+from numpy import asmatrix, bmat, matrix
+from numpy.linalg import matrix_power
+from numpy.testing import (
+    assert_,
+    assert_almost_equal,
+    assert_array_almost_equal,
+    assert_array_equal,
+    assert_equal,
+    assert_raises,
+)
+
+
+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))
+        mx = x.view(np.matrix)
+        assert_(mx.ptp() == 3)
+        assert_(np.all(mx.ptp(0) == np.array([2, 2])))
+        assert_(np.all(mx.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', 'to_device',
+            'take', 'tofile', 'tolist', 'tobytes', 'all', 'any',
+            'sum', 'argmax', 'argmin', 'min', 'max', 'mean', 'var', 'ptp',
+            'prod', 'std', 'ctypes', 'bitwise_count',
+            ]
+        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)
+                args = methodargs.get(attrib, ())
+                b = f(*args)
+                assert_(type(b) is matrix, f"{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 = asmatrix(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))