Beispiel #1
0
def test_constant_equiv():
    n = 10
    constant = 1.5

    w_const = FnConstWeighting(constant)
    w_const2 = FnConstWeighting(constant)

    const_sparse_mat = sp.sparse.dia_matrix(([constant] * n, [0]),
                                            shape=(n, n))
    const_dense_mat = constant * np.eye(n)
    w_matrix_sp = FnMatrixWeighting(const_sparse_mat)
    w_matrix_de = FnMatrixWeighting(const_dense_mat)

    # Equal -> True
    assert w_const.equiv(w_const)
    assert w_const.equiv(w_const2)
    # Equivalent matrix representation -> True
    assert w_const.equiv(w_matrix_sp)
    assert w_const.equiv(w_matrix_de)

    w_different_const = FnConstWeighting(2.5)
    assert not w_const.equiv(w_different_const)

    # Bogus input
    assert not w_const.equiv(True)
    assert not w_const.equiv(object)
    assert not w_const.equiv(None)
Beispiel #2
0
def test_constant_equals():
    n = 10
    constant = 1.5

    w_const = FnConstWeighting(constant)
    w_const2 = FnConstWeighting(constant)
    w_other_const = FnConstWeighting(constant + 1)
    w_other_exp = FnConstWeighting(constant, exponent=1)

    const_sparse_mat = sp.sparse.dia_matrix(([constant] * n, [0]),
                                            shape=(n, n))
    const_dense_mat = constant * np.eye(n)
    w_matrix_sp = FnMatrixWeighting(const_sparse_mat)
    w_matrix_de = FnMatrixWeighting(const_dense_mat)

    assert w_const == w_const
    assert w_const == w_const2
    assert w_const2 == w_const
    # Equivalent but not equal -> False
    assert w_const != w_matrix_sp
    assert w_const != w_matrix_de

    # Different
    assert w_const != w_other_const
    assert w_const != w_other_exp
Beispiel #3
0
def test_matrix_matrix():
    fn = Rn(5)
    sparse_mat = _sparse_matrix(fn)
    dense_mat = _dense_matrix(fn)

    w_sparse = FnMatrixWeighting(sparse_mat)
    w_dense = FnMatrixWeighting(dense_mat)

    assert isinstance(w_sparse.matrix, sp.sparse.spmatrix)
    assert isinstance(w_dense.matrix, np.ndarray)
Beispiel #4
0
def test_matrix_init(fn, exponent):
    sparse_mat = _sparse_matrix(fn)
    dense_mat = _dense_matrix(fn)

    # Just test if the code runs
    FnMatrixWeighting(dense_mat, exponent=exponent)
    if exponent in (1.0, 2.0, float('inf')):
        FnMatrixWeighting(sparse_mat, exponent=exponent)
    else:
        with pytest.raises(NotImplementedError):
            FnMatrixWeighting(sparse_mat, exponent=exponent)

    nonsquare_mat = np.eye(10, 5)
    with pytest.raises(ValueError):
        FnMatrixWeighting(nonsquare_mat)
Beispiel #5
0
def test_matrix_is_valid():
    fn = Rn(5)
    sparse_mat = _sparse_matrix(fn)
    dense_mat = _dense_matrix(fn)
    bad_mat = np.eye(5)
    bad_mat[0, 0] = 0

    w_sparse = FnMatrixWeighting(sparse_mat)
    w_dense = FnMatrixWeighting(dense_mat)
    w_bad = FnMatrixWeighting(bad_mat)

    with pytest.raises(NotImplementedError):
        w_sparse.is_valid()

    assert w_dense.is_valid()
    assert not w_bad.is_valid()
Beispiel #6
0
def test_matrix_dist_using_inner(fn):
    xarr, yarr, x, y = _vectors(fn, 2)
    mat = _dense_matrix(fn)

    w = FnMatrixWeighting(mat, dist_using_inner=True)

    true_dist = np.sqrt(np.vdot(xarr - yarr, np.dot(mat, xarr - yarr)))
    assert almost_equal(w.dist(x, y), true_dist)

    # Only possible for exponent=2
    with pytest.raises(ValueError):
        FnMatrixWeighting(mat, exponent=1, dist_using_inner=True)

    # With free function
    w_dist = weighted_dist(mat, use_inner=True)
    assert almost_equal(w_dist(x, y), true_dist)
    assert almost_equal(w.dist(x, x), 0)
Beispiel #7
0
def test_matrix_equals(fn, exponent):
    sparse_mat = _sparse_matrix(fn)
    sparse_mat_as_dense = sparse_mat.todense()
    dense_mat = _dense_matrix(fn)
    different_dense_mat = dense_mat.copy()
    different_dense_mat[0, 0] -= 1

    if exponent in (1.0, 2.0, float('inf')):
        w_sparse = FnMatrixWeighting(sparse_mat, exponent=exponent)
        w_sparse2 = FnMatrixWeighting(sparse_mat, exponent=exponent)
    w_sparse_as_dense = FnMatrixWeighting(sparse_mat_as_dense,
                                          exponent=exponent)
    w_dense = FnMatrixWeighting(dense_mat, exponent=exponent)
    w_dense2 = FnMatrixWeighting(dense_mat, exponent=exponent)
    w_different_mat = FnMatrixWeighting(different_dense_mat, exponent=exponent)
    diff_exp = exponent + 1 if np.isfinite(exponent) else 1
    w_different_exp = FnMatrixWeighting(dense_mat, exponent=diff_exp)

    # Identical objects -> True
    assert w_dense == w_dense
    # Identical matrices -> True
    if exponent in (1.0, 2.0, float('inf')):
        assert w_sparse == w_sparse2
    assert w_dense == w_dense2
    # Equivalent but not identical matrices -> False
    if exponent in (1.0, 2.0, float('inf')):
        assert w_sparse != w_sparse_as_dense
        assert w_sparse_as_dense != w_sparse
    # Not equivalent -> False
    assert w_dense != w_different_mat
    # Different exponents -> False
    assert w_dense != w_different_exp
Beispiel #8
0
def test_matrix_norm(fn, exponent):
    xarr, x = _vectors(fn)
    sparse_mat = _sparse_matrix(fn)
    sparse_mat_as_dense = np.asarray(sparse_mat.todense())
    dense_mat = _dense_matrix(fn)

    # Compute true matrix-weighted norm
    if exponent == 1.0:  # ||x||_{A,1} = ||Ax||_1
        true_norm_sparse = np.linalg.norm(np.dot(sparse_mat_as_dense, xarr),
                                          ord=exponent)
        true_norm_dense = np.linalg.norm(np.dot(dense_mat, xarr),
                                         ord=exponent)
    elif exponent == 2.0:  # ||x||_{A,2} = sqrt(<x, Ax>)
        true_norm_sparse = np.sqrt(
            np.vdot(xarr, np.dot(sparse_mat_as_dense, xarr)))
        true_norm_dense = np.sqrt(np.vdot(xarr, np.dot(dense_mat, xarr)))
    elif exponent == float('inf'):  # ||x||_{A,inf} = ||Ax||_inf
        true_norm_sparse = np.linalg.norm(sparse_mat_as_dense.dot(xarr),
                                          ord=exponent)
        true_norm_dense = np.linalg.norm(dense_mat.dot(xarr), ord=exponent)
    else:  # ||x||_{A,p} = ||A^{1/p} x||_p
        # Calculate matrix power
        eigval, eigvec = sp.linalg.eigh(dense_mat)
        eigval **= 1.0 / exponent
        mat_pow = (eigval * eigvec).dot(eigvec.conj().T)
        true_norm_dense = np.linalg.norm(np.dot(mat_pow, xarr), ord=exponent)

    # Test weighting
    if exponent in (1.0, 2.0, float('inf')):
        w_sparse = FnMatrixWeighting(sparse_mat, exponent=exponent)
        assert almost_equal(w_sparse.norm(x), true_norm_sparse)

    w_dense = FnMatrixWeighting(dense_mat, exponent=exponent)
    assert almost_equal(w_dense.norm(x), true_norm_dense)

    # With free functions
    if exponent not in (1.0, 2.0, float('inf')):
        with pytest.raises(NotImplementedError):
            weighted_norm(sparse_mat, exponent=exponent)
    else:
        w_sparse_norm = weighted_norm(sparse_mat, exponent=exponent)
        assert almost_equal(w_sparse_norm(x), true_norm_sparse)

    w_dense_norm = weighted_norm(dense_mat, exponent=exponent)
    assert almost_equal(w_dense_norm(x), true_norm_dense)
Beispiel #9
0
def test_matrix_dist_using_inner(fn):
    [xarr, yarr], [x, y] = example_vectors(fn, 2)
    mat = _dense_matrix(fn)

    w = FnMatrixWeighting(mat, dist_using_inner=True)

    true_dist = np.sqrt(np.vdot(xarr - yarr, np.dot(mat, xarr - yarr)))
    # Using 3 places (single precision default) since the result is always
    # double even if the underlying computation was only single precision
    assert almost_equal(w.dist(x, y), true_dist, places=3)

    # Only possible for exponent=2
    with pytest.raises(ValueError):
        FnMatrixWeighting(mat, exponent=1, dist_using_inner=True)

    # With free function
    w_dist = weighted_dist(mat, use_inner=True)
    assert almost_equal(w_dist(x, y), true_dist)
Beispiel #10
0
def test_matrix_dist(fn, exponent):
    xarr, yarr, x, y = _vectors(fn, n=2)
    sparse_mat = _sparse_matrix(fn)
    sparse_mat_as_dense = np.asarray(sparse_mat.todense())
    dense_mat = _dense_matrix(fn)

    if exponent == 1.0:  # d(x, y)_{A,1} = ||A(x-y)||_1
        true_dist_sparse = np.linalg.norm(
            np.dot(sparse_mat_as_dense, xarr - yarr), ord=exponent)
        true_dist_dense = np.linalg.norm(
            np.dot(dense_mat, xarr - yarr), ord=exponent)
    elif exponent == 2.0:  # d(x, y)_{A,2} = sqrt(<x-y, A(x-y)>)
        true_dist_sparse = np.sqrt(
            np.vdot(xarr - yarr, np.dot(sparse_mat_as_dense, xarr - yarr)))
        true_dist_dense = np.sqrt(
            np.vdot(xarr - yarr, np.dot(dense_mat, xarr - yarr)))
    elif exponent == float('inf'):  # d(x, y)_{A,inf} = ||A(x-y)||_inf
        true_dist_sparse = np.linalg.norm(sparse_mat_as_dense.dot(xarr - yarr),
                                          ord=exponent)
        true_dist_dense = np.linalg.norm(dense_mat.dot(xarr - yarr),
                                         ord=exponent)
    else:  # d(x, y)_{A,p} = ||A^{1/p} (x-y)||_p
        # Calculate matrix power
        eigval, eigvec = sp.linalg.eigh(dense_mat)
        eigval **= 1.0 / exponent
        mat_pow = (eigval * eigvec).dot(eigvec.conj().T)
        true_dist_dense = np.linalg.norm(np.dot(mat_pow, xarr - yarr),
                                         ord=exponent)

    if exponent in (1.0, 2.0, float('inf')):
        w_sparse = FnMatrixWeighting(sparse_mat, exponent=exponent)
        assert almost_equal(w_sparse.dist(x, y), true_dist_sparse)

    w_dense = FnMatrixWeighting(dense_mat, exponent=exponent)
    assert almost_equal(w_dense.dist(x, y), true_dist_dense)

    # With free functions
    if exponent in (1.0, 2.0, float('inf')):
        w_sparse_dist = weighted_dist(sparse_mat, exponent=exponent)
        assert almost_equal(w_sparse_dist(x, y), true_dist_sparse)

    w_dense_dist = weighted_dist(dense_mat, exponent=exponent)
    assert almost_equal(w_dense_dist(x, y), true_dist_dense)
Beispiel #11
0
def test_matrix_inner(fn):
    [xarr, yarr], [x, y] = example_vectors(fn, 2)
    sparse_mat = _sparse_matrix(fn)
    sparse_mat_as_dense = np.asarray(sparse_mat.todense())
    dense_mat = _dense_matrix(fn)

    true_inner_sparse = np.vdot(yarr, np.dot(sparse_mat_as_dense, xarr))
    true_inner_dense = np.vdot(yarr, np.dot(dense_mat, xarr))

    w_sparse = FnMatrixWeighting(sparse_mat)
    w_dense = FnMatrixWeighting(dense_mat)
    assert almost_equal(w_sparse.inner(x, y), true_inner_sparse)
    assert almost_equal(w_dense.inner(x, y), true_inner_dense)

    # With free functions
    w_sparse_inner = weighted_inner(sparse_mat)
    w_dense_inner = weighted_inner(dense_mat)
    assert almost_equal(w_sparse_inner(x, y), true_inner_sparse)
    assert almost_equal(w_dense_inner(x, y), true_inner_dense)

    # Exponent != 2 -> no inner
    w_dense = FnMatrixWeighting(dense_mat, exponent=1)
    with pytest.raises(NotImplementedError):
        w_dense.inner(x, y)
Beispiel #12
0
def test_matrix_isvalid():
    fn = Rn(5)
    sparse_mat = _sparse_matrix(fn)
    dense_mat = _dense_matrix(fn)
    bad_mat = np.eye(5)
    bad_mat[0, 0] = 0

    w_sparse = FnMatrixWeighting(sparse_mat)
    w_dense = FnMatrixWeighting(dense_mat)
    w_bad = FnMatrixWeighting(bad_mat)

    with pytest.raises(NotImplementedError):
        w_sparse.matrix_isvalid()

    assert w_dense.matrix_isvalid()
    assert not w_bad.matrix_isvalid()
Beispiel #13
0
def test_init_weighting(exponent):
    const = 1.5
    weight_vec = _pos_array(Rn(3, float))
    weight_mat = _dense_matrix(Rn(3, float))

    spaces = [
        Fn(3, complex, exponent=exponent, weight=const),
        Fn(3, complex, exponent=exponent, weight=weight_vec),
        Fn(3, complex, exponent=exponent, weight=weight_mat)
    ]
    weightings = [
        FnConstWeighting(const, exponent=exponent),
        FnVectorWeighting(weight_vec, exponent=exponent),
        FnMatrixWeighting(weight_mat, exponent=exponent)
    ]

    for spc, weight in zip(spaces, weightings):
        assert spc.weighting == weight
Beispiel #14
0
def test_matrix_norm(fn, exponent):
    xarr, x = example_vectors(fn)
    sparse_mat = _sparse_matrix(fn)
    sparse_mat_as_dense = np.asarray(sparse_mat.todense())
    dense_mat = _dense_matrix(fn)

    # Compute true matrix-weighted norm
    if exponent == 1.0:  # ||x||_{A,1} = ||Ax||_1
        true_norm_sparse = np.linalg.norm(np.dot(sparse_mat_as_dense, xarr),
                                          ord=exponent)
        true_norm_dense = np.linalg.norm(np.dot(dense_mat, xarr), ord=exponent)
    elif exponent == 2.0:  # ||x||_{A,2} = sqrt(<x, Ax>)
        true_norm_sparse = np.sqrt(
            np.vdot(xarr, np.dot(sparse_mat_as_dense, xarr)))
        true_norm_dense = np.sqrt(np.vdot(xarr, np.dot(dense_mat, xarr)))
    elif exponent == float('inf'):  # ||x||_{A,inf} = ||Ax||_inf
        true_norm_sparse = np.linalg.norm(sparse_mat_as_dense.dot(xarr),
                                          ord=exponent)
        true_norm_dense = np.linalg.norm(dense_mat.dot(xarr), ord=exponent)
    else:  # ||x||_{A,p} = ||A^{1/p} x||_p
        # Calculate matrix power
        eigval, eigvec = sp.linalg.eigh(dense_mat)
        eigval **= 1.0 / exponent
        mat_pow = (eigval * eigvec).dot(eigvec.conj().T)
        true_norm_dense = np.linalg.norm(np.dot(mat_pow, xarr), ord=exponent)

    # Test weighting
    if exponent in (1.0, 2.0, float('inf')):
        w_sparse = FnMatrixWeighting(sparse_mat, exponent=exponent)
        assert almost_equal(w_sparse.norm(x), true_norm_sparse)

    w_dense = FnMatrixWeighting(dense_mat, exponent=exponent)
    assert almost_equal(w_dense.norm(x), true_norm_dense)

    # With free functions
    if exponent not in (1.0, 2.0, float('inf')):
        with pytest.raises(NotImplementedError):
            weighted_norm(sparse_mat, exponent=exponent)
    else:
        w_sparse_norm = weighted_norm(sparse_mat, exponent=exponent)
        assert almost_equal(w_sparse_norm(x), true_norm_sparse)

    w_dense_norm = weighted_norm(dense_mat, exponent=exponent)
    assert almost_equal(w_dense_norm(x), true_norm_dense)
Beispiel #15
0
def test_matrix_dist(fn, exponent):
    [xarr, yarr], [x, y] = example_vectors(fn, n=2)
    sparse_mat = _sparse_matrix(fn)
    sparse_mat_as_dense = np.asarray(sparse_mat.todense())
    dense_mat = _dense_matrix(fn)

    if exponent == 1.0:  # d(x, y)_{A,1} = ||A(x-y)||_1
        true_dist_sparse = np.linalg.norm(np.dot(sparse_mat_as_dense,
                                                 xarr - yarr),
                                          ord=exponent)
        true_dist_dense = np.linalg.norm(np.dot(dense_mat, xarr - yarr),
                                         ord=exponent)
    elif exponent == 2.0:  # d(x, y)_{A,2} = sqrt(<x-y, A(x-y)>)
        true_dist_sparse = np.sqrt(
            np.vdot(xarr - yarr, np.dot(sparse_mat_as_dense, xarr - yarr)))
        true_dist_dense = np.sqrt(
            np.vdot(xarr - yarr, np.dot(dense_mat, xarr - yarr)))
    elif exponent == float('inf'):  # d(x, y)_{A,inf} = ||A(x-y)||_inf
        true_dist_sparse = np.linalg.norm(sparse_mat_as_dense.dot(xarr - yarr),
                                          ord=exponent)
        true_dist_dense = np.linalg.norm(dense_mat.dot(xarr - yarr),
                                         ord=exponent)
    else:  # d(x, y)_{A,p} = ||A^{1/p} (x-y)||_p
        # Calculate matrix power
        eigval, eigvec = sp.linalg.eigh(dense_mat)
        eigval **= 1.0 / exponent
        mat_pow = (eigval * eigvec).dot(eigvec.conj().T)
        true_dist_dense = np.linalg.norm(np.dot(mat_pow, xarr - yarr),
                                         ord=exponent)

    if exponent in (1.0, 2.0, float('inf')):
        w_sparse = FnMatrixWeighting(sparse_mat, exponent=exponent)
        assert almost_equal(w_sparse.dist(x, y), true_dist_sparse)

    w_dense = FnMatrixWeighting(dense_mat, exponent=exponent)
    assert almost_equal(w_dense.dist(x, y), true_dist_dense)

    # With free functions
    if exponent in (1.0, 2.0, float('inf')):
        w_sparse_dist = weighted_dist(sparse_mat, exponent=exponent)
        assert almost_equal(w_sparse_dist(x, y), true_dist_sparse)

    w_dense_dist = weighted_dist(dense_mat, exponent=exponent)
    assert almost_equal(w_dense_dist(x, y), true_dist_dense)
Beispiel #16
0
def test_vector_equiv():
    rn = Rn(5)
    weight_vec = _pos_array(rn)
    weight_elem = rn.element(weight_vec)
    diag_mat = weight_vec * np.eye(5)
    different_vec = weight_vec - 1

    w_vec = FnVectorWeighting(weight_vec)
    w_elem = FnVectorWeighting(weight_elem)
    w_diag_mat = FnMatrixWeighting(diag_mat)
    w_different_vec = FnVectorWeighting(different_vec)

    # Equal -> True
    assert w_vec.equiv(w_vec)
    assert w_vec.equiv(w_elem)
    # Equivalent matrix -> True
    assert w_vec.equiv(w_diag_mat)
    # Different vector -> False
    assert not w_vec.equiv(w_different_vec)

    # Test shortcuts
    const_vec = np.ones(5) * 1.5

    w_vec = FnVectorWeighting(const_vec)
    w_const = FnConstWeighting(1.5)
    w_wrong_const = FnConstWeighting(1)
    w_wrong_exp = FnConstWeighting(1.5, exponent=1)

    assert w_vec.equiv(w_const)
    assert not w_vec.equiv(w_wrong_const)
    assert not w_vec.equiv(w_wrong_exp)

    # Bogus input
    assert not w_vec.equiv(True)
    assert not w_vec.equiv(object)
    assert not w_vec.equiv(None)
Beispiel #17
0
def test_matrix_inner(fn):
    xarr, yarr, x, y = _vectors(fn, 2)
    sparse_mat = _sparse_matrix(fn)
    sparse_mat_as_dense = np.asarray(sparse_mat.todense())
    dense_mat = _dense_matrix(fn)

    true_inner_sparse = np.vdot(yarr, np.dot(sparse_mat_as_dense, xarr))
    true_inner_dense = np.vdot(yarr, np.dot(dense_mat, xarr))

    w_sparse = FnMatrixWeighting(sparse_mat)
    w_dense = FnMatrixWeighting(dense_mat)
    assert almost_equal(w_sparse.inner(x, y), true_inner_sparse)
    assert almost_equal(w_dense.inner(x, y), true_inner_dense)

    # With free functions
    w_sparse_inner = weighted_inner(sparse_mat)
    w_dense_inner = weighted_inner(dense_mat)
    assert almost_equal(w_sparse_inner(x, y), true_inner_sparse)
    assert almost_equal(w_dense_inner(x, y), true_inner_dense)

    # Exponent != 2 -> no inner
    w_dense = FnMatrixWeighting(dense_mat, exponent=1)
    with pytest.raises(NotImplementedError):
        w_dense.inner(x, y)
Beispiel #18
0
def test_matrix_equiv():
    fn = Rn(5)
    sparse_mat = _sparse_matrix(fn)
    sparse_mat_as_dense = sparse_mat.todense()
    dense_mat = _dense_matrix(fn)
    different_dense_mat = dense_mat.copy()
    different_dense_mat[0, 0] = -10

    w_sparse = FnMatrixWeighting(sparse_mat)
    w_sparse2 = FnMatrixWeighting(sparse_mat)
    w_sparse_as_dense = FnMatrixWeighting(sparse_mat_as_dense)
    w_dense = FnMatrixWeighting(dense_mat)
    w_dense_copy = FnMatrixWeighting(dense_mat.copy())
    w_different_dense = FnMatrixWeighting(different_dense_mat)

    # Equal -> True
    assert w_sparse.equiv(w_sparse)
    assert w_sparse.equiv(w_sparse2)
    # Equivalent matrices -> True
    assert w_sparse.equiv(w_sparse_as_dense)
    assert w_dense.equiv(w_dense_copy)
    # Different matrices -> False
    assert not w_dense.equiv(w_different_dense)

    # Test shortcuts
    sparse_eye = sp.sparse.eye(5)
    w_eye = FnMatrixWeighting(sparse_eye)
    w_dense_eye = FnMatrixWeighting(sparse_eye.todense())
    w_eye_vec = FnVectorWeighting(np.ones(5))

    w_eye_wrong_exp = FnMatrixWeighting(sparse_eye, exponent=1)

    sparse_smaller_eye = sp.sparse.eye(4)
    w_smaller_eye = FnMatrixWeighting(sparse_smaller_eye)

    sparse_shifted_eye = sp.sparse.eye(5, k=1)
    w_shifted_eye = FnMatrixWeighting(sparse_shifted_eye)

    sparse_almost_eye = sp.sparse.dia_matrix((np.ones(4), [0]), (5, 5))
    w_almost_eye = FnMatrixWeighting(sparse_almost_eye)

    assert w_eye.equiv(w_dense_eye)
    assert w_dense_eye.equiv(w_eye)
    assert w_eye.equiv(w_eye_vec)
    assert not w_eye.equiv(w_eye_wrong_exp)
    assert not w_eye.equiv(w_smaller_eye)
    assert not w_eye.equiv(w_shifted_eye)
    assert not w_smaller_eye.equiv(w_shifted_eye)
    assert not w_eye.equiv(w_almost_eye)

    # Bogus input
    assert not w_eye.equiv(True)
    assert not w_eye.equiv(object)
    assert not w_eye.equiv(None)
Beispiel #19
0
def test_matrix_equiv():
    fn = Rn(5)
    sparse_mat = _sparse_matrix(fn)
    sparse_mat_as_dense = sparse_mat.todense()
    dense_mat = _dense_matrix(fn)
    different_dense_mat = dense_mat.copy()
    different_dense_mat[0, 0] = -10

    w_sparse = FnMatrixWeighting(sparse_mat)
    w_sparse2 = FnMatrixWeighting(sparse_mat)
    w_sparse_as_dense = FnMatrixWeighting(sparse_mat_as_dense)
    w_dense = FnMatrixWeighting(dense_mat)
    w_dense_copy = FnMatrixWeighting(dense_mat.copy())
    w_different_dense = FnMatrixWeighting(different_dense_mat)

    # Equal -> True
    assert w_sparse.equiv(w_sparse)
    assert w_sparse.equiv(w_sparse2)
    # Equivalent matrices -> True
    assert w_sparse.equiv(w_sparse_as_dense)
    assert w_dense.equiv(w_dense_copy)
    # Different matrices -> False
    assert not w_dense.equiv(w_different_dense)

    # Test shortcuts
    sparse_eye = sp.sparse.eye(5)
    w_eye = FnMatrixWeighting(sparse_eye)
    w_dense_eye = FnMatrixWeighting(sparse_eye.todense())
    w_eye_vec = FnVectorWeighting(np.ones(5))

    w_eye_wrong_exp = FnMatrixWeighting(sparse_eye, exponent=1)

    sparse_smaller_eye = sp.sparse.eye(4)
    w_smaller_eye = FnMatrixWeighting(sparse_smaller_eye)

    sparse_shifted_eye = sp.sparse.eye(5, k=1)
    w_shifted_eye = FnMatrixWeighting(sparse_shifted_eye)

    sparse_almost_eye = sp.sparse.dia_matrix((np.ones(4), [0]), (5, 5))
    w_almost_eye = FnMatrixWeighting(sparse_almost_eye)

    assert w_eye.equiv(w_dense_eye)
    assert w_dense_eye.equiv(w_eye)
    assert w_eye.equiv(w_eye_vec)
    assert not w_eye.equiv(w_eye_wrong_exp)
    assert not w_eye.equiv(w_smaller_eye)
    assert not w_eye.equiv(w_shifted_eye)
    assert not w_smaller_eye.equiv(w_shifted_eye)
    assert not w_eye.equiv(w_almost_eye)

    # Bogus input
    assert not w_eye.equiv(True)
    assert not w_eye.equiv(object)
    assert not w_eye.equiv(None)