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)
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
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)
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)
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()
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)
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
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)
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)
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)
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)
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()
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
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)
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)
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)
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)
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)