def test_scal(vector_array): v = vector_array for ind in valid_inds(v): if v.len_ind(ind) != v.len_ind_unique(ind): with pytest.raises(Exception): c = v.copy() c[ind].scal(1.) continue ind_complement_ = ind_complement(v, ind) c = v.copy() c[ind].scal(1.) assert len(c) == len(v) assert np.all(almost_equal(c, v)) c = v.copy() c[ind].scal(0.) assert np.all(almost_equal(c[ind], v.zeros(v.len_ind(ind)))) assert np.all(almost_equal(c[ind_complement_], v[ind_complement_])) for x in (1., 1.4, np.random.random(v.len_ind(ind))): c = v.copy() c[ind].scal(x) assert np.all(almost_equal(c[ind_complement_], v[ind_complement_])) assert np.allclose(c[ind].sup_norm(), v[ind].sup_norm() * abs(x)) assert np.allclose(c[ind].l2_norm(), v[ind].l2_norm() * abs(x)) try: y = v.to_numpy(True) if isinstance(x, np.ndarray) and not isinstance(ind, Number): x = x[:, np.newaxis] y[ind] *= x assert np.allclose(c.to_numpy(), y) except NotImplementedError: pass
def test_InverseAdjointOperator(operator_with_arrays): op, mu, U, V = operator_with_arrays if not op.linear: return inv = InverseAdjointOperator(op) rtol = atol = 1e-12 try: assert np.all(almost_equal(inv.apply(U, mu=mu), op.apply_inverse_adjoint(U, mu=mu), rtol=rtol, atol=atol)) except (InversionError, LinAlgError, NotImplementedError): pass try: assert np.all(almost_equal(inv.apply_inverse(V, mu=mu), op.apply_adjoint(V, mu=mu), rtol=rtol, atol=atol)) except (InversionError, LinAlgError, NotImplementedError): pass try: assert np.all(almost_equal(inv.apply_adjoint(V, mu=mu), op.apply_inverse(V, mu=mu), rtol=rtol, atol=atol)) except (InversionError, LinAlgError, NotImplementedError): pass try: assert np.all(almost_equal(inv.apply_inverse_adjoint(U, mu=mu), op.apply(U, mu=mu), rtol=rtol, atol=atol)) except (InversionError, LinAlgError, NotImplementedError): pass
def test_append(compatible_vector_array_pair): v1, v2 = compatible_vector_array_pair len_v1, len_v2 = len(v1), len(v2) for ind in valid_inds(v2): c1, c2 = v1.copy(), v2.copy() c1.append(c2[ind]) len_ind = v2.len_ind(ind) ind_complement_ = ind_complement(v2, ind) assert len(c1) == len_v1 + len_ind assert np.all(almost_equal(c1[len_v1:len(c1)], c2[ind])) try: assert np.allclose( c1.to_numpy(), np.vstack((v1.to_numpy(), indexed(v2.to_numpy(), ind)))) except NotImplementedError: pass c1.append(c2[ind], remove_from_other=True) assert len(c2) == len(ind_complement_) assert c2.space == c1.space assert len(c1) == len_v1 + 2 * len_ind assert np.all( almost_equal(c1[len_v1:len_v1 + len_ind], c1[len_v1 + len_ind:len(c1)])) assert np.all(almost_equal(c2, v2[ind_complement_])) try: assert np.allclose(c2.to_numpy(), indexed(v2.to_numpy(), ind_complement_)) except NotImplementedError: pass
def test_sub(vector_arrays): v1, v2 = vector_arrays c1 = v1.copy() cc1 = v1.copy() c1.axpy(-1, v2) assert np.all(almost_equal((v1 - v2), c1)) assert np.all(almost_equal(v1, cc1))
def test_assemble(operator_with_arrays): op, mu, U, V = operator_with_arrays aop = op.assemble(mu=mu) assert op.source == aop.source assert op.range == aop.range assert np.all(almost_equal(aop.apply(U), op.apply(U, mu=mu))) try: ATV = op.apply_adjoint(V, mu=mu) except (NotImplementedError, LinAlgError): ATV = None if ATV is not None: assert np.all(almost_equal(aop.apply_adjoint(V), ATV)) try: AIV = op.apply_inverse(V, mu=mu) except InversionError: AIV = None if AIV is not None: assert np.all(almost_equal(aop.apply_inverse(V), AIV)) try: AITU = op.apply_inverse_adjoint(U, mu=mu) except (InversionError, LinAlgError): AITU = None if AITU is not None: assert np.all(almost_equal(aop.apply_inverse_adjoint(U), AITU))
def test_lincomb_op(): p1 = MonomOperator(1) p2 = MonomOperator(2) p12 = p1 + p2 p0 = p1 - p1 x = np.linspace(-1., 1., num=3) vx = p1.source.make_array((x[:, np.newaxis])) one = p1.source.make_array([1]) assert np.allclose(p0.apply(vx).to_numpy(), [0.]) assert np.allclose(p12.apply(vx).to_numpy(), (x * x + x)[:, np.newaxis]) assert np.allclose((p1 * 2.).apply(vx).to_numpy(), (x * 2.)[:, np.newaxis]) with pytest.raises(AssertionError): p2.jacobian(vx) for i in range(len(vx)): assert almost_equal( p2.jacobian(vx[i]).apply(one), p1.apply(vx[i]) * 2.) assert almost_equal(p0.jacobian(vx[i]).apply(one), vx[i] * 0.) with pytest.raises(TypeError): p2.as_vector() p1.as_vector() assert almost_equal(p1.as_vector(), p1.apply(p1.source.make_array([1.]))) basis = p1.source.make_array([1.]) for p in (p1, p2, p12): projected = project(p, basis, basis) pa = projected.apply(vx) assert almost_equal(pa, p.apply(vx)).all()
def test_neg(vector_array): v = vector_array c = v.copy() cc = v.copy() c.scal(-1) assert np.all(almost_equal(c, -v)) assert np.all(almost_equal(v, cc))
def test_lincomb_op_with_zero_coefficients(): p1 = MonomOperator(1) p2 = MonomOperator(2) p10 = p1 + 0 * p2 p0 = 0 * p1 + 0 * p1 x = np.linspace(-1., 1., num=3) vx = p1.source.make_array((x[:, np.newaxis])) pc1 = NumpyMatrixOperator(np.eye(p1.source.dim)) pc2 = NumpyMatrixOperator(2 * np.eye(p1.source.dim)) pc10 = pc1 + 0 * pc2 pc0 = 0 * pc1 + 0 * pc2 assert np.allclose(p0.apply(vx).to_numpy(), [0.]) assert len(p0.apply(vx)) == len(vx) assert almost_equal(p10.apply(vx), p1.apply(vx)).all() assert np.allclose(p0.apply2(vx, vx), [0.]) assert len(p0.apply2(vx, vx)) == len(vx) assert np.allclose(p10.apply2(vx, vx), p1.apply2(vx, vx)) assert np.allclose(p0.pairwise_apply2(vx, vx), [0.]) assert len(p0.pairwise_apply2(vx, vx)) == len(vx) assert np.allclose(p10.pairwise_apply2(vx, vx), p1.pairwise_apply2(vx, vx)) assert np.allclose(pc0.apply_adjoint(vx).to_numpy(), [0.]) assert len(pc0.apply_adjoint(vx)) == len(vx) assert almost_equal(pc10.apply_adjoint(vx), pc1.apply_adjoint(vx)).all()
def test_scal(vector_array): v = vector_array for ind in valid_inds(v): if v.len_ind(ind) != v.len_ind_unique(ind): with pytest.raises(Exception): c = v.copy() c[ind].scal(1.) continue ind_complement_ = ind_complement(v, ind) c = v.copy() c[ind].scal(1.) assert len(c) == len(v) assert np.all(almost_equal(c, v)) c = v.copy() c[ind].scal(0.) assert np.all(almost_equal(c[ind], v.zeros(v.len_ind(ind)))) assert np.all(almost_equal(c[ind_complement_], v[ind_complement_])) for x in (1., 1.4, np.random.random(v.len_ind(ind))): c = v.copy() c[ind].scal(x) assert np.all(almost_equal(c[ind_complement_], v[ind_complement_])) assert np.allclose(c[ind].sup_norm(), v[ind].sup_norm() * abs(x)) assert np.allclose(c[ind].l2_norm(), v[ind].l2_norm() * abs(x)) if hasattr(v, 'data'): y = v.data.copy() if NUMPY_INDEX_QUIRK and len(y) == 0: pass else: if isinstance(x, np.ndarray) and not isinstance(ind, Number): x = x[:, np.newaxis] y[ind] *= x assert np.allclose(c.data, y)
def test_almost_equal_incompatible(vector_arrays): v1, v2 = vector_arrays for ind1, ind2 in valid_inds_of_same_length(v1, v2): for sup_norm in (False, True): c1, c2 = v1.copy(), v2.copy() with pytest.raises(Exception): almost_equal(c1[ind1], c2[ind2], sup_norm=sup_norm)
def test_append(compatible_vector_array_pair): v1, v2 = compatible_vector_array_pair if hasattr(v1, 'data'): dv1 = v1.data dv2 = v2.data len_v1, len_v2 = len(v1), len(v2) for ind in valid_inds(v2): c1, c2 = v1.copy(), v2.copy() c1.append(c2, o_ind=ind) len_ind = v2.len_ind(ind) ind_complement_ = ind_complement(v2, ind) assert len(c1) == len_v1 + len_ind assert np.all( almost_equal(c1, c2, U_ind=list(range(len_v1, len(c1))), V_ind=ind)) if hasattr(v1, 'data'): assert np.allclose(c1.data, np.vstack((dv1, indexed(dv2, ind)))) c1.append(c2, o_ind=ind, remove_from_other=True) assert len(c2) == len(ind_complement_) assert c2.dim == c1.dim assert c2.subtype == c1.subtype assert len(c1) == len_v1 + 2 * len_ind assert np.all( almost_equal(c1, c1, U_ind=list(range(len_v1, len_v1 + len_ind)), V_ind=list(range(len_v1 + len_ind, len(c1))))) assert np.all(almost_equal(c2, v2, V_ind=ind_complement_)) if hasattr(v1, 'data'): assert np.allclose(c2.data, indexed(dv2, ind_complement_))
def test_almost_equal_incompatible(incompatible_vector_array_pair): v1, v2 = incompatible_vector_array_pair for ind1, ind2 in valid_inds_of_same_length(v1, v2): for n in ['sup', 'l1', 'l2']: c1, c2 = v1.copy(), v2.copy() with pytest.raises(Exception): almost_equal(c1[ind1], c2[ind2], norm=n)
def test_add(vector_arrays): v1, v2 = vector_arrays c1 = v1.copy() cc1 = v1.copy() c1.axpy(1, v2) assert np.all(almost_equal(v1 + v2, c1)) assert np.all(almost_equal(v1, cc1))
def test_rmul(vector_array): c = vector_array.copy() for a in (-1, -3, 0, 1, 23): cc = vector_array.copy() cc.scal(a) assert np.all(almost_equal((a * vector_array), cc)) assert np.all(almost_equal(vector_array, c))
def test_mul(vector_array): c = vector_array.copy() for a in (-1, -3, 0, 1, 23, np.arange(len(vector_array))): cc = vector_array.copy() cc.scal(a) assert np.all(almost_equal((vector_array * a), cc)) assert np.all(almost_equal(vector_array, c))
def test_mul(vector_array): v = vector_array c = v.copy() for a in (-1, -3, 0, 1, 23): cc = v.copy() cc.scal(a) assert np.all(almost_equal((v * a), cc)) assert np.all(almost_equal(v, c))
def test_rmul(vector_array): v = vector_array c = v.copy() for a in (-1, -3, 0, 1, 23): cc = v.copy() cc.scal(a) assert np.all(almost_equal((a * v), cc)) assert np.all(almost_equal(v, c))
def test_identity_lincomb(): space = NumpyVectorSpace(10) identity = IdentityOperator(space) ones = space.ones() idid = (identity + identity) assert almost_equal(ones * 2, idid.apply(ones)) assert almost_equal(ones * 2, idid.apply_adjoint(ones)) assert almost_equal(ones * 0.5, idid.apply_inverse(ones)) assert almost_equal(ones * 0.5, idid.apply_inverse_adjoint(ones))
def test_apply(operator_with_arrays): op, mu, U, _ = operator_with_arrays V = op.apply(U, mu=mu) assert V in op.range assert len(V) == len(U) for ind in valid_inds(U): Vind = op.apply(U[ind], mu=mu) assert np.all(almost_equal(Vind, V[ind])) assert np.all(almost_equal(Vind, op.apply(U[ind], mu=mu)))
def test_axpy_one_x(compatible_vector_array_pair): v1, v2 = compatible_vector_array_pair if hasattr(v1, 'data'): dv1 = v1.data dv2 = v2.data for ind1, ind2 in product(valid_inds(v1), valid_inds(v2, 1)): if v1.len_ind(ind1) != v1.len_ind_unique(ind1): with pytest.raises(Exception): c1, c2 = v1.copy(), v2.copy() c1.axpy(0., c2, ind=ind1, x_ind=ind2) continue ind1_complement = ind_complement(v1, ind1) c1, c2 = v1.copy(), v2.copy() c1.axpy(0., c2, ind=ind1, x_ind=ind2) assert len(c1) == len(v1) assert np.all(almost_equal(c1, v1)) assert np.all(almost_equal(c2, v2)) np.random.seed(len(v1) + 39) for a in (1., 1.4, np.random.random(v1.len_ind(ind1))): c1, c2 = v1.copy(), v2.copy() c1.axpy(a, c2, ind=ind1, x_ind=ind2) assert len(c1) == len(v1) assert np.all( almost_equal(c1, v1, U_ind=ind1_complement, V_ind=ind1_complement)) assert np.all(almost_equal(c2, v2)) assert np.all( c1.sup_norm(ind1) <= v1.sup_norm(ind1) + abs(a) * v2.sup_norm(ind2) * (1. + 1e-10)) assert np.all( c1.l1_norm(ind1) <= (v1.l1_norm(ind1) + abs(a) * v2.l1_norm(ind2)) * (1. + 1e-10)) assert np.all( c1.l2_norm(ind1) <= (v1.l2_norm(ind1) + abs(a) * v2.l2_norm(ind2)) * (1. + 1e-10)) if hasattr(v1, 'data'): x = dv1.copy() if isinstance(ind1, Number): x[[ind1]] += indexed(dv2, ind2) * a else: if NUMPY_INDEX_QUIRK and len(x) == 0: pass else: if isinstance(a, np.ndarray): aa = a[:, np.newaxis] else: aa = a x[ind1] += indexed(dv2, ind2) * aa assert np.allclose(c1.data, x) c1.axpy(-a, c2, ind=ind1, x_ind=ind2) assert len(c1) == len(v1) assert np.all(almost_equal(c1, v1))
def test_almost_equal_wrong_ind(compatible_vector_array_pair): v1, v2 = compatible_vector_array_pair for ind1, ind2 in invalid_ind_pairs(v1, v2): for n in ['sup', 'l1', 'l2']: if (ind1 is None and len(v1) == 1 or isinstance(ind1, Number) or hasattr(ind1, '__len__') and len(ind1) == 1 or # NOQA ind2 is None and len(v2) == 1 or isinstance(ind2, Number) or hasattr(ind2, '__len__') and len(ind2) == 1): # NOQA continue c1, c2 = v1.copy(), v2.copy() with pytest.raises(Exception): almost_equal(c1[ind], c2[ind], norm=n)
def test_lincomb_adjoint(): op = LincombOperator([NumpyMatrixOperator(np.eye(10)), NumpyMatrixOperator(np.eye(10))], [1+3j, ExpressionParameterFunctional('c[0] + 3', {'c': 1})]) mu = op.parameters.parse(1j) U = op.range.random() V = op.apply_adjoint(U, mu=mu) VV = op.H.apply(U, mu=mu) assert np.all(almost_equal(V, VV)) VVV = op.apply(U, mu=mu).conj() assert np.all(almost_equal(V, VVV))
def test_almost_equal_wrong_ind(compatible_vector_array_pair): v1, v2 = compatible_vector_array_pair for ind1, ind2 in invalid_ind_pairs(v1, v2): for n in ['sup', 'l1', 'l2']: if (ind1 is None and len(v1) == 1 or isinstance(ind1, Number) or hasattr(ind1, '__len__') and len(ind1) == 1 or ind2 is None and len(v2) == 1 or isinstance(ind2, Number) or hasattr(ind2, '__len__') and len(ind2) == 1): # NOQA continue c1, c2 = v1.copy(), v2.copy() with pytest.raises(Exception): almost_equal(c1, c2, U_ind=ind1, V_ind=ind2, norm=n)
def test_axpy_one_x(vector_arrays, random): v1, v2 = vector_arrays for ind1, ind2 in product(pyst.valid_inds(v1, random_module=False), pyst.valid_inds(v2, 1, random_module=False)): assert v1.check_ind(ind1) assert v2.check_ind(ind2) if v1.len_ind(ind1) != v1.len_ind_unique(ind1): with pytest.raises(Exception): c1, c2 = v1.copy(), v2.copy() c1[ind1].axpy(0., c2[ind2]) continue ind1_complement = ind_complement(v1, ind1) c1, c2 = v1.copy(), v2.copy() gc = c1[ind1] gv = c2[ind2] # TODO this was somehow hardcoded in the old fixture, makes the test extremely slow assume(len(gc) == 0 or len(gv) > 0) gc.axpy(0., gv) assert len(c1) == len(v1) assert np.all(almost_equal(c1, v1)) assert np.all(almost_equal(c2, v2)) for a in (1., 1.4, np.random.random(v1.len_ind(ind1))): c1, c2 = v1.copy(), v2.copy() c1[ind1].axpy(a, c2[ind2]) assert len(c1) == len(v1) assert np.all( almost_equal(c1[ind1_complement], v1[ind1_complement])) assert np.all(almost_equal(c2, v2)) # for the openstack CI machines this could be 1 + 1e-10 rtol_factor = 1. + 147e-9 assert np.all(c1[ind1].sup_norm() <= v1[ind1].sup_norm() + abs(a) * v2[ind2].sup_norm() * rtol_factor) assert np.all(c1[ind1].norm() <= (v1[ind1].norm() + abs(a) * v2[ind2].norm()) * (1. + 1e-10)) try: x = v1.to_numpy(True).astype( complex) # ensure that inplace addition works if isinstance(ind1, Number): x[[ind1]] += indexed(v2.to_numpy(), ind2) * a else: if isinstance(a, np.ndarray): aa = a[:, np.newaxis] else: aa = a x[ind1] += indexed(v2.to_numpy(), ind2) * aa assert np.allclose(c1.to_numpy(), x) except NotImplementedError: pass c1[ind1].axpy(-a, c2[ind2]) assert len(c1) == len(v1) assert np.all(almost_equal(c1, v1))
def test_axpy_self(vector_array): v = vector_array if hasattr(v, 'data'): dv = v.data for ind1, ind2 in valid_inds_of_same_length(v, v): if v.len_ind(ind1) != v.len_ind_unique(ind1): with pytest.raises(Exception): c, = v.copy() c.axpy(0., c, ind=ind1, x_ind=ind2) continue ind1_complement = ind_complement(v, ind1) c = v.copy() c.axpy(0., c, ind=ind1, x_ind=ind2) assert len(c) == len(v) assert np.all(almost_equal(c, v)) assert np.all(almost_equal(c, v)) np.random.seed(len(v) + 8) for a in (1., 1.4, np.random.random(v.len_ind(ind1))): c = v.copy() c.axpy(a, c, ind=ind1, x_ind=ind2) assert len(c) == len(v) assert np.all(almost_equal(c, v, U_ind=ind1_complement, V_ind=ind1_complement)) assert np.all(c.sup_norm(ind1) <= v.sup_norm(ind1) + abs(a) * v.sup_norm(ind2) * (1. + 1e-10)) assert np.all(c.l1_norm(ind1) <= (v.l1_norm(ind1) + abs(a) * v.l1_norm(ind2)) * (1. + 1e-10)) if hasattr(v, 'data'): x = dv.copy() if isinstance(ind1, Number): x[[ind1]] += indexed(dv, ind2) * a else: if NUMPY_INDEX_QUIRK and len(x) == 0: pass else: if isinstance(a, np.ndarray): aa = a[:, np.newaxis] else: aa = a x[ind1] += indexed(dv, ind2) * aa assert np.allclose(c.data, x) c.axpy(-a, v, ind=ind1, x_ind=ind2) assert len(c) == len(v) assert np.all(almost_equal(c, v)) for ind in valid_inds(v): if v.len_ind(ind) != v.len_ind_unique(ind): continue for x in (1., 23., -4): c = v.copy() cc = v.copy() c.axpy(x, c, ind=ind, x_ind=ind) cc.scal(1 + x, ind=ind) assert np.all(almost_equal(c, cc))
def test_axpy_self(vector_array): v = vector_array for ind1, ind2 in valid_inds_of_same_length(v, v): if v.len_ind(ind1) != v.len_ind_unique(ind1): with pytest.raises(Exception): c, = v.copy() c[ind1].axpy(0., c[ind2]) continue ind1_complement = ind_complement(v, ind1) c = v.copy() c[ind1].axpy(0., c[ind2]) assert len(c) == len(v) assert np.all(almost_equal(c, v)) np.random.seed(len(v) + 8) for a in (1., 1.4, np.random.random(v.len_ind(ind1))): c = v.copy() c[ind1].axpy(a, c[ind2]) assert len(c) == len(v) assert np.all(almost_equal(c[ind1_complement], v[ind1_complement])) assert np.all(c[ind1].sup_norm() <= v[ind1].sup_norm() + abs(a) * v[ind2].sup_norm() * (1. + 1e-10)) assert np.all(c[ind1].l1_norm() <= (v[ind1].l1_norm() + abs(a) * v[ind2].l1_norm()) * (1. + 1e-10)) if hasattr(v, 'data'): x = v.data.copy() if isinstance(ind1, Number): x[[ind1]] += indexed(v.data, ind2) * a else: if NUMPY_INDEX_QUIRK and len(x) == 0: pass else: if isinstance(a, np.ndarray): aa = a[:, np.newaxis] else: aa = a x[ind1] += indexed(v.data, ind2) * aa assert np.allclose(c.data, x) c[ind1].axpy(-a, v[ind2]) assert len(c) == len(v) assert np.all(almost_equal(c, v)) for ind in valid_inds(v): if v.len_ind(ind) != v.len_ind_unique(ind): continue for x in (1., 23., -4): c = v.copy() cc = v.copy() c[ind].axpy(x, c[ind]) cc[ind].scal(1 + x) assert np.all(almost_equal(c, cc))
def test_sub(compatible_vector_array_pair): v1, v2 = compatible_vector_array_pair if len(v2) < len(v1): v2.append(v2[np.zeros(len(v1) - len(v2), dtype=np.int)]) elif len(v2) > len(v1): del v2[list(range(len(v2) - len(v1)))] c1 = v1.copy() cc1 = v1.copy() c1.axpy(-1, v2) assert np.all(almost_equal((v1 - v2), c1)) assert np.all(almost_equal(v1, cc1))
def test_add(compatible_vector_array_pair): v1, v2 = compatible_vector_array_pair if len(v2) < len(v1): v2.append(v2, o_ind=np.zeros(len(v1) - len(v2), dtype=np.int)) elif len(v2) > len(v1): v2.remove(range(len(v2)-len(v1))) c1 = v1.copy() cc1 = v1.copy() c1.axpy(1, v2) assert np.all(almost_equal(v1 + v2, c1)) assert np.all(almost_equal(v1, cc1))
def test_add(compatible_vector_array_pair): v1, v2 = compatible_vector_array_pair if len(v2) < len(v1): v2.append(v2, o_ind=np.zeros(len(v1) - len(v2), dtype=np.int)) elif len(v2) > len(v1): v2.remove(list(range(len(v2) - len(v1)))) c1 = v1.copy() cc1 = v1.copy() c1.axpy(1, v2) assert np.all(almost_equal(v1 + v2, c1)) assert np.all(almost_equal(v1, cc1))
def test_add(compatible_vector_array_pair): v1, v2 = compatible_vector_array_pair if len(v2) < len(v1): v2.append(v2[np.zeros(len(v1) - len(v2), dtype=np.int)]) elif len(v2) > len(v1): del v2[:len(v2) - len(v1)] c1 = v1.copy() cc1 = v1.copy() c1.axpy(1, v2) assert np.all(almost_equal(v1 + v2, c1)) assert np.all(almost_equal(v1, cc1))
def test_add(compatible_vector_array_pair): v1, v2 = compatible_vector_array_pair if len(v2) < len(v1): v2.append(v2[np.zeros(len(v1) - len(v2), dtype=np.int)]) elif len(v2) > len(v1): del v2[:len(v2)-len(v1)] c1 = v1.copy() cc1 = v1.copy() c1.axpy(1, v2) assert np.all(almost_equal(v1 + v2, c1)) assert np.all(almost_equal(v1, cc1))
def test_sub(compatible_vector_array_pair): v1, v2 = compatible_vector_array_pair if len(v2) < len(v1): v2.append(v2[np.zeros(len(v1) - len(v2), dtype=np.int)]) elif len(v2) > len(v1): del v2[list(range(len(v2)-len(v1)))] c1 = v1.copy() cc1 = v1.copy() c1.axpy(-1, v2) assert np.all(almost_equal((v1 - v2), c1)) assert np.all(almost_equal(v1, cc1))
def test_gram_schmidt(vector_array): U = vector_array V = U.copy() onb = gram_schmidt(U, copy=True) assert np.all(almost_equal(U, V)) assert np.allclose(onb.dot(onb), np.eye(len(onb))) assert np.all(almost_equal(U, onb.lincomb(U.dot(onb)), rtol=1e-13)) onb2 = gram_schmidt(U, copy=False) assert np.all(almost_equal(onb, onb2)) assert np.all(almost_equal(onb, U))
def test_apply_adjoint(operator_with_arrays): op, mu, _, V = operator_with_arrays try: U = op.apply_adjoint(V, mu=mu) except NotImplementedError: return assert U in op.source assert len(V) == len(U) for ind in list(valid_inds(V, 3)) + [[]]: Uind = op.apply_adjoint(V, mu=mu, ind=ind) assert np.all(almost_equal(Uind, U, V_ind=ind)) assert np.all(almost_equal(Uind, op.apply_adjoint(V.copy(ind=ind), mu=mu)))
def test_gram_schmidt_with_product(operator_with_arrays_and_products): _, _, U, _, p, _ = operator_with_arrays_and_products V = U.copy() onb = gram_schmidt(U, product=p, copy=True) assert np.all(almost_equal(U, V)) assert np.allclose(p.apply2(onb, onb), np.eye(len(onb))) assert np.all(almost_equal(U, onb.lincomb(p.apply2(onb, U).T), rtol=1e-13)) onb2 = gram_schmidt(U, product=p, copy=False) assert np.all(almost_equal(onb, onb2)) assert np.all(almost_equal(onb, U))
def test_block_identity_lincomb(): space = NumpyVectorSpace(10) space2 = BlockVectorSpace([space, space]) identity = BlockDiagonalOperator([IdentityOperator(space), IdentityOperator(space)]) identity2 = IdentityOperator(space2) ones = space.ones() ones2 = space2.make_array([ones, ones]) idid = identity + identity2 assert almost_equal(ones2 * 2, idid.apply(ones2)) assert almost_equal(ones2 * 2, idid.apply_adjoint(ones2)) assert almost_equal(ones2 * 0.5, idid.apply_inverse(ones2)) assert almost_equal(ones2 * 0.5, idid.apply_inverse_adjoint(ones2))
def test_gram_schmidt_with_product(operator_with_arrays_and_products): _, _, U, _, p, _ = operator_with_arrays_and_products V = U.copy() onb = gram_schmidt(U, product=p, copy=True) assert np.all(almost_equal(U, V)) assert np.allclose(p.apply2(onb, onb), np.eye(len(onb))) assert np.all(almost_equal(U, onb.lincomb(p.apply2(U, onb)), rtol=1e-13)) onb2 = gram_schmidt(U, product=p, copy=False) assert np.all(almost_equal(onb, onb2)) assert np.all(almost_equal(onb, U))
def test_axpy_self(vector_array): v = vector_array for ind1, ind2 in valid_inds_of_same_length(v, v): if v.len_ind(ind1) != v.len_ind_unique(ind1): with pytest.raises(Exception): c, = v.copy() c[ind1].axpy(0., c[ind2]) continue ind1_complement = ind_complement(v, ind1) c = v.copy() c[ind1].axpy(0., c[ind2]) assert len(c) == len(v) assert np.all(almost_equal(c, v)) np.random.seed(len(v) + 8) for a in (1., 1.4, np.random.random(v.len_ind(ind1))): c = v.copy() c[ind1].axpy(a, c[ind2]) assert len(c) == len(v) assert np.all(almost_equal(c[ind1_complement], v[ind1_complement])) assert np.all(c[ind1].sup_norm() <= v[ind1].sup_norm() + abs(a) * v[ind2].sup_norm() * (1. + 1e-10)) try: x = v.to_numpy(True).astype( complex) # ensure that inplace addition works if isinstance(ind1, Number): x[[ind1]] += indexed(v.to_numpy(), ind2) * a else: if isinstance(a, np.ndarray): aa = a[:, np.newaxis] else: aa = a x[ind1] += indexed(v.to_numpy(), ind2) * aa assert np.allclose(c.to_numpy(), x) except NotImplementedError: pass c[ind1].axpy(-a, v[ind2]) assert len(c) == len(v) assert np.all(almost_equal(c, v)) for ind in valid_inds(v): if v.len_ind(ind) != v.len_ind_unique(ind): continue for x in (1., 23., -4): c = v.copy() cc = v.copy() c[ind].axpy(x, c[ind]) cc[ind].scal(1 + x) assert np.all(almost_equal(c, cc))
def test_axpy_self(vector_array): v = vector_array for ind1, ind2 in valid_inds_of_same_length(v, v): if v.len_ind(ind1) != v.len_ind_unique(ind1): with pytest.raises(Exception): c, = v.copy() c[ind1].axpy(0., c[ind2]) continue ind1_complement = ind_complement(v, ind1) c = v.copy() c[ind1].axpy(0., c[ind2]) assert len(c) == len(v) assert np.all(almost_equal(c, v)) np.random.seed(len(v) + 8) for a in (1., 1.4, np.random.random(v.len_ind(ind1))): c = v.copy() c[ind1].axpy(a, c[ind2]) assert len(c) == len(v) assert np.all(almost_equal(c[ind1_complement], v[ind1_complement])) assert np.all(c[ind1].sup_norm() <= v[ind1].sup_norm() + abs(a) * v[ind2].sup_norm() * (1. + 1e-10)) assert np.all(c[ind1].l1_norm() <= (v[ind1].l1_norm() + abs(a) * v[ind2].l1_norm()) * (1. + 1e-10)) try: x = v.to_numpy(True) if isinstance(ind1, Number): x[[ind1]] += indexed(v.to_numpy(), ind2) * a else: if isinstance(a, np.ndarray): aa = a[:, np.newaxis] else: aa = a x[ind1] += indexed(v.to_numpy(), ind2) * aa assert np.allclose(c.to_numpy(), x) except NotImplementedError: pass c[ind1].axpy(-a, v[ind2]) assert len(c) == len(v) assert np.all(almost_equal(c, v)) for ind in valid_inds(v): if v.len_ind(ind) != v.len_ind_unique(ind): continue for x in (1., 23., -4): c = v.copy() cc = v.copy() c[ind].axpy(x, c[ind]) cc[ind].scal(1 + x) assert np.all(almost_equal(c, cc))
def test_gram_schmidt_with_R(vector_array): U = vector_array V = U.copy() onb, R = gram_schmidt(U, return_R=True, copy=True) assert np.all(almost_equal(U, V)) assert np.allclose(onb.dot(onb), np.eye(len(onb))) assert np.all(almost_equal(U, onb.lincomb(U.dot(onb)), rtol=1e-13)) assert np.all(almost_equal(V, onb.lincomb(R.T))) onb2, R2 = gram_schmidt(U, return_R=True, copy=False) assert np.all(almost_equal(onb, onb2)) assert np.all(R == R2) assert np.all(almost_equal(onb, U))
def test_projected_2(operator_with_arrays): op, mu, U, V = operator_with_arrays op_U = op.projected(None, U) op_V = op.projected(V, None) op_U_V = op_U.projected(V, None) op_V_U = op_V.projected(None, U) op_UV = op.projected(V, U) np.random.seed(4711 + U.dim + len(V)) W = NumpyVectorArray(np.random.random(len(U)), copy=False) Y0 = op_UV.apply(W, mu=mu) Y1 = op_U_V.apply(W, mu=mu) Y2 = op_V_U.apply(W, mu=mu) assert np.all(almost_equal(Y0, Y1)) assert np.all(almost_equal(Y0, Y2))
def test_project_2(operator_with_arrays): op, mu, U, V = operator_with_arrays op_U = project(op, None, U) op_V = project(op, V, None) op_U_V = project(op_U, V, None) op_V_U = project(op_V, None, U) op_UV = project(op, V, U) np.random.seed(4711 + U.dim + len(V)) W = op_UV.source.make_array(np.random.random(len(U))) Y0 = op_UV.apply(W, mu=mu) Y1 = op_U_V.apply(W, mu=mu) Y2 = op_V_U.apply(W, mu=mu) assert np.all(almost_equal(Y0, Y1)) assert np.all(almost_equal(Y0, Y2))
def test_apply_transpose(operator_with_arrays): op, mu, _, V = operator_with_arrays if not op.linear: return try: U = op.apply_transpose(V, mu=mu) except NotImplementedError: return assert U in op.source assert len(V) == len(U) for ind in list(valid_inds(V, 3)) + [[]]: Uind = op.apply_transpose(V[ind], mu=mu) assert np.all(almost_equal(Uind, U[ind])) assert np.all(almost_equal(Uind, op.apply_transpose(V[ind], mu=mu)))
def test_projected_with_product_2(operator_with_arrays_and_products): op, mu, U, V, sp, rp = operator_with_arrays_and_products op_U = op.projected(None, U) op_V = op.projected(V, None, product=rp) op_U_V = op_U.projected(V, None, product=rp) op_V_U = op_V.projected(None, U) op_UV = op.projected(V, U, product=rp) np.random.seed(4711 + U.dim + len(V)) W = op_UV.source.make_array(np.random.random(len(U))) Y0 = op_UV.apply(W, mu=mu) Y1 = op_U_V.apply(W, mu=mu) Y2 = op_V_U.apply(W, mu=mu) assert np.all(almost_equal(Y0, Y1)) assert np.all(almost_equal(Y0, Y2))
def test_gram_schmidt_biorth(vector_array): U = vector_array if U.dim < 2: return l = len(U) // 2 l = min((l, U.dim - 1)) if l < 1: return U1 = U[:l].copy() U2 = U[l:2 * l].copy() V1 = U1.copy() V2 = U2.copy() A1, A2 = gram_schmidt_biorth(U1, U2, copy=True) assert np.all(almost_equal(U1, V1)) assert np.all(almost_equal(U2, V2)) assert np.allclose(A2.dot(A1), np.eye(len(A1))) c = np.linalg.cond(A1.to_numpy()) * np.linalg.cond(A2.to_numpy()) assert np.all(almost_equal(U1, A1.lincomb(U1.dot(A2)), rtol=c * 1e-14)) assert np.all(almost_equal(U2, A2.lincomb(U2.dot(A1)), rtol=c * 1e-14)) B1, B2 = gram_schmidt_biorth(U1, U2, copy=False) assert np.all(almost_equal(A1, B1)) assert np.all(almost_equal(A2, B2)) assert np.all(almost_equal(A1, U1)) assert np.all(almost_equal(A2, U2))
def test_gram_schmidt_biorth_with_product(operator_with_arrays_and_products): _, _, U, _, p, _ = operator_with_arrays_and_products if U.dim < 2: return l = len(U) // 2 l = min((l, U.dim - 1)) if l < 1: return U1 = U[:l].copy() U2 = U[l:2 * l].copy() V1 = U1.copy() V2 = U2.copy() A1, A2 = gram_schmidt_biorth(U1, U2, product=p, copy=True) assert np.all(almost_equal(U1, V1)) assert np.all(almost_equal(U2, V2)) assert np.allclose(p.apply2(A2, A1), np.eye(len(A1))) c = np.linalg.cond(A1.to_numpy()) * np.linalg.cond(p.apply(A2).to_numpy()) assert np.all(almost_equal(U1, A1.lincomb(p.apply2(U1, A2)), rtol=c * 1e-14)) assert np.all(almost_equal(U2, A2.lincomb(p.apply2(U2, A1)), rtol=c * 1e-14)) B1, B2 = gram_schmidt_biorth(U1, U2, product=p, copy=False) assert np.all(almost_equal(A1, B1)) assert np.all(almost_equal(A2, B2)) assert np.all(almost_equal(A1, U1)) assert np.all(almost_equal(A2, U2))
def test_replace_self(vector_array): v = vector_array if hasattr(v, 'data'): dv = v.data for ind1, ind2 in valid_inds_of_same_length(v, v): if v.len_ind(ind1) != v.len_ind_unique(ind1): c = v.copy() with pytest.raises(Exception): c.replace(c, ind=ind1, o_ind=ind2, remove_from_other=False) c = v.copy() with pytest.raises(Exception): c.replace(c, ind=ind1, o_ind=ind2, remove_from_other=True) continue c = v.copy() with pytest.raises(Exception): c.replace(c, ind=ind1, o_ind=ind2, remove_from_other=True) c = v.copy() c.replace(c, ind=ind1, o_ind=ind2, remove_from_other=False) assert len(c) == len(v) assert c.dim == v.dim assert c.subtype == v.subtype assert np.all(almost_equal(c, v, U_ind=ind1, V_ind=ind2)) if hasattr(v, 'data'): x = dv.copy() if NUMPY_INDEX_QUIRK and len(x) == 0 and hasattr(ind1, '__len__') and len(ind1) == 0: pass else: x[ind1] = indexed(dv, ind2) assert np.allclose(c.data, x)
def test_copy_repeated_index(vector_array): v = vector_array if len(v) == 0: return ind = [int(len(vector_array) * 3 / 4)] * 2 for deep in (True, False): c = v[ind].copy(deep) assert almost_equal(c[0], v[ind[0]]) assert almost_equal(c[1], v[ind[0]]) if hasattr(v, 'data'): assert indexed(v.data, ind).shape == c.data.shape c[0].scal(2.) assert almost_equal(c[1], v[ind[0]]) assert c[0].l2_norm() == 2 * v[ind[0]].l2_norm() if hasattr(v, 'data'): assert indexed(v.data, ind).shape == c.data.shape
def test_pickle_by_solving(discretization): d = discretization d2 = loads(dumps(d)) d.disable_caching() d2.disable_caching() for mu in d.parameter_space.sample_randomly(3, seed=234): assert np.all(almost_equal(d.solve(mu), d2.solve(mu)))
def test_pickle_by_solving(model): m = model m2 = loads(dumps(m)) m.disable_caching() m2.disable_caching() for mu in m.parameter_space.sample_randomly(3, seed=234): assert np.all(almost_equal(m.solve(mu), m2.solve(mu)))
def extend_basis(U, basis, product=None, method='gram_schmidt', pod_modes=1, pod_orthonormalize=True, copy_U=True): assert method in ('trivial', 'gram_schmidt', 'pod') basis_length = len(basis) if method == 'trivial': remove = set() for i in range(len(U)): if np.any(almost_equal(U[i], basis)): remove.add(i) basis.append(U[[i for i in range(len(U)) if i not in remove]], remove_from_other=(not copy_U)) elif method == 'gram_schmidt': basis.append(U, remove_from_other=(not copy_U)) gram_schmidt(basis, offset=basis_length, product=product, copy=False, check=False) elif method == 'pod': U_proj_err = U - basis.lincomb(U.inner(basis, product)) basis.append(pod(U_proj_err, modes=pod_modes, product=product, orthonormalize=False)[0]) if pod_orthonormalize: gram_schmidt(basis, offset=basis_length, product=product, copy=False, check=False) if len(basis) <= basis_length: raise ExtensionError