def test_project_array(): np.random.seed(123) U = NumpyVectorSpace.from_numpy(np.random.random((2, 10))) basis = NumpyVectorSpace.from_numpy(np.random.random((3, 10))) U_p = project_array(U, basis, orthonormal=False) onb = gram_schmidt(basis) U_p2 = project_array(U, onb, orthonormal=True) assert np.all(relative_error(U_p, U_p2) < 1e-10)
def test_project_array(): np.random.seed(123) U = NumpyVectorSpace.from_numpy(np.random.random((2, 10))) basis = NumpyVectorSpace.from_numpy(np.random.random((3, 10))) U_p = project_array(U, basis, orthonormal=False) onb = gram_schmidt(basis) U_p2 = project_array(U, onb, orthonormal=True) assert np.all(relative_error(U_p, U_p2) < 1e-10)
def numpy_vector_array_factory(length, dim, seed): np.random.seed(seed) if np.random.randint(2): return NumpyVectorSpace.from_numpy(np.random.random((length, dim))) else: return NumpyVectorSpace.from_numpy( np.random.random((length, dim)) + np.random.random((length, dim)) * 1j)
def test_project_array_with_product(): np.random.seed(123) U = NumpyVectorSpace.from_numpy(np.random.random((1, 10))) basis = NumpyVectorSpace.from_numpy(np.random.random((3, 10))) product = np.random.random((10, 10)) product = NumpyMatrixOperator(product.T.dot(product)) U_p = project_array(U, basis, product=product, orthonormal=False) onb = gram_schmidt(basis, product=product) U_p2 = project_array(U, onb, product=product, orthonormal=True) assert np.all(relative_error(U_p, U_p2, product) < 1e-10)
def test_axpy(): x = NumpyVectorSpace.from_numpy(np.array([1.])) y = NumpyVectorSpace.from_numpy(np.array([1.])) y.axpy(1 + 1j, x) assert y.to_numpy()[0, 0] == 2 + 1j x = NumpyVectorSpace.from_numpy(np.array([1 + 1j])) y = NumpyVectorSpace.from_numpy(np.array([1.])) y.axpy(-1, x) assert y.to_numpy()[0, 0] == -1j
def test_project_array_with_product(): np.random.seed(123) U = NumpyVectorSpace.from_numpy(np.random.random((1, 10))) basis = NumpyVectorSpace.from_numpy(np.random.random((3, 10))) product = np.random.random((10, 10)) product = NumpyMatrixOperator(product.T.dot(product)) U_p = project_array(U, basis, product=product, orthonormal=False) onb = gram_schmidt(basis, product=product) U_p2 = project_array(U, onb, product=product, orthonormal=True) assert np.all(relative_error(U_p, U_p2, product) < 1e-10)
def test_axpy(): x = NumpyVectorSpace.from_numpy(np.array([1.])) y = NumpyVectorSpace.from_numpy(np.array([1.])) y.axpy(1 + 1j, x) assert y.to_numpy()[0, 0] == 2 + 1j x = NumpyVectorSpace.from_numpy(np.array([1 + 1j])) y = NumpyVectorSpace.from_numpy(np.array([1.])) y.axpy(-1, x) assert y.to_numpy()[0, 0] == -1j
def test_complex(): np.random.seed(0) I = np.eye(5) A = np.random.randn(5, 5) B = np.random.randn(5, 5) C = np.random.randn(3, 5) Iop = NumpyMatrixOperator(I) Aop = NumpyMatrixOperator(A) Bop = NumpyMatrixOperator(B) Cva = NumpyVectorSpace.from_numpy(C) # assemble_lincomb assert not np.iscomplexobj(Aop.assemble_lincomb([Iop, Bop], [1, 1]).matrix) assert not np.iscomplexobj(Aop.assemble_lincomb([Aop, Bop], [1, 1]).matrix) assert np.iscomplexobj( Aop.assemble_lincomb([Aop, Bop], [1 + 0j, 1 + 0j]).matrix) assert np.iscomplexobj(Aop.assemble_lincomb([Aop, Bop], [1j, 1]).matrix) assert np.iscomplexobj(Aop.assemble_lincomb([Bop, Aop], [1, 1j]).matrix) # apply_inverse assert not np.iscomplexobj(Aop.apply_inverse(Cva).to_numpy()) assert np.iscomplexobj((Aop * 1j).apply_inverse(Cva).to_numpy()) assert np.iscomplexobj( Aop.assemble_lincomb([Aop, Bop], [1, 1j]).apply_inverse(Cva).to_numpy()) assert np.iscomplexobj(Aop.apply_inverse(Cva * 1j).to_numpy()) # append for rsrv in (0, 10): for o_ind in (slice(None), [0]): va = NumpyVectorSpace(5).empty(reserve=rsrv) va.append(Cva) D = np.random.randn(1, 5) + 1j * np.random.randn(1, 5) Dva = NumpyVectorSpace.from_numpy(D) assert not np.iscomplexobj(va.to_numpy()) assert np.iscomplexobj(Dva.to_numpy()) va.append(Dva[o_ind]) assert np.iscomplexobj(va.to_numpy()) # scal assert not np.iscomplexobj(Cva.to_numpy()) assert np.iscomplexobj((Cva * 1j).to_numpy()) assert np.iscomplexobj((Cva * (1 + 0j)).to_numpy()) # axpy assert not np.iscomplexobj(Cva.to_numpy()) Cva[0].axpy(1, Dva) assert np.iscomplexobj(Cva.to_numpy()) Cva = NumpyVectorSpace.from_numpy(C) assert not np.iscomplexobj(Cva.to_numpy()) Cva[0].axpy(1j, Dva) assert np.iscomplexobj(Cva.to_numpy())
def test_complex(): np.random.seed(0) I = np.eye(5) A = np.random.randn(5, 5) B = np.random.randn(5, 5) C = np.random.randn(3, 5) Iop = NumpyMatrixOperator(I) Aop = NumpyMatrixOperator(A) Bop = NumpyMatrixOperator(B) Cva = NumpyVectorSpace.from_numpy(C) # lincombs assert not np.iscomplexobj((Iop * 1 + Bop * 1).assemble().matrix) assert not np.iscomplexobj((Aop * 1 + Bop * 1).assemble().matrix) assert np.iscomplexobj((Aop * (1+0j) + Bop * (1+0j)).assemble().matrix) assert np.iscomplexobj((Aop * 1j + Bop * 1).assemble().matrix) assert np.iscomplexobj((Bop * 1 + Aop * 1j).assemble().matrix) # apply_inverse assert not np.iscomplexobj(Aop.apply_inverse(Cva).to_numpy()) assert np.iscomplexobj((Aop * 1j).apply_inverse(Cva).to_numpy()) assert np.iscomplexobj((Aop * 1 + Bop * 1j).assemble().apply_inverse(Cva).to_numpy()) assert np.iscomplexobj(Aop.apply_inverse(Cva * 1j).to_numpy()) # append for rsrv in (0, 10): for o_ind in (slice(None), [0]): va = NumpyVectorSpace(5).empty(reserve=rsrv) va.append(Cva) D = np.random.randn(1, 5) + 1j * np.random.randn(1, 5) Dva = NumpyVectorSpace.from_numpy(D) assert not np.iscomplexobj(va.to_numpy()) assert np.iscomplexobj(Dva.to_numpy()) va.append(Dva[o_ind]) assert np.iscomplexobj(va.to_numpy()) # scal assert not np.iscomplexobj(Cva.to_numpy()) assert np.iscomplexobj((Cva * 1j).to_numpy()) assert np.iscomplexobj((Cva * (1 + 0j)).to_numpy()) # axpy assert not np.iscomplexobj(Cva.to_numpy()) Cva[0].axpy(1, Dva) assert np.iscomplexobj(Cva.to_numpy()) Cva = NumpyVectorSpace.from_numpy(C) assert not np.iscomplexobj(Cva.to_numpy()) Cva[0].axpy(1j, Dva) assert np.iscomplexobj(Cva.to_numpy())
def test_scal(): v = np.array([[1, 2, 3], [4, 5, 6]], dtype=float) v = NumpyVectorSpace.from_numpy(v) v.scal(1j) k = 0 for i in range(2): for j in range(3): k += 1 assert v.to_numpy()[i, j] == k * 1j
def test_blk_diag_apply_inverse_adjoint(): np.random.seed(0) A = np.random.randn(2, 2) B = np.random.randn(3, 3) C = spla.block_diag(A, B) Aop = NumpyMatrixOperator(A) Bop = NumpyMatrixOperator(B) Cop = BlockDiagonalOperator((Aop, Bop)) v1 = np.random.randn(2) v2 = np.random.randn(3) v = np.hstack((v1, v2)) v1va = NumpyVectorSpace.from_numpy(v1) v2va = NumpyVectorSpace.from_numpy(v2) vva = BlockVectorSpace.make_array((v1va, v2va)) wva = Cop.apply_inverse_adjoint(vva) w = np.hstack((wva.block(0).to_numpy(), wva.block(1).to_numpy())) assert np.allclose(spla.solve(C.T, v), w)
def test_blk_diag_apply_inverse_adjoint(): np.random.seed(0) A = np.random.randn(2, 2) B = np.random.randn(3, 3) C = spla.block_diag(A, B) Aop = NumpyMatrixOperator(A) Bop = NumpyMatrixOperator(B) Cop = BlockDiagonalOperator((Aop, Bop)) v1 = np.random.randn(2) v2 = np.random.randn(3) v = np.hstack((v1, v2)) v1va = NumpyVectorSpace.from_numpy(v1) v2va = NumpyVectorSpace.from_numpy(v2) vva = BlockVectorSpace.make_array((v1va, v2va)) wva = Cop.apply_inverse_adjoint(vva) w = np.hstack((wva.block(0).to_numpy(), wva.block(1).to_numpy())) assert np.allclose(spla.solve(C.T, v), w)
def test_vtkio(rect_or_tria_grid): grid = rect_or_tria_grid steps = 4 for dim in range(1, 2): for codim, data in enumerate((NumpyVectorSpace.from_numpy(np.zeros((steps, grid.size(c)))) for c in range(grid.dim+1))): with SafeTemporaryFileName('wb') as out_name: if codim == 1: with pytest.raises(NotImplementedError): write_vtk(grid, data, out_name, codim=codim) else: write_vtk(grid, data, out_name, codim=codim)
def test_scal(): v = np.array([[1, 2, 3], [4, 5, 6]], dtype=float) v = NumpyVectorSpace.from_numpy(v) v.scal(1j) k = 0 for i in range(2): for j in range(3): k += 1 assert v.to_numpy()[i, j] == k * 1j
def test_vtkio(grid): steps = 4 for dim in range(1, 2): for codim, data in enumerate( (NumpyVectorSpace.from_numpy(np.zeros((steps, grid.size(c)))) for c in range(grid.dim + 1))): with SafeTemporaryFileName('wb') as out_name: if codim == 1: with pytest.raises(NotImplementedError): write_vtk(grid, data, out_name, codim=codim) else: write_vtk(grid, data, out_name, codim=codim)
def test_real_imag(): A = np.array([[1 + 2j, 3 + 4j], [5 + 6j, 7 + 8j], [9 + 10j, 11 + 12j]]) Ava = NumpyVectorSpace.from_numpy(A) Bva = Ava.real Cva = Ava.imag k = 0 for i in range(3): for j in range(2): k += 1 assert Bva.to_numpy()[i, j] == k k += 1 assert Cva.to_numpy()[i, j] == k
def test_apply_adjoint(): np.random.seed(0) A11 = np.random.randn(2, 3) A12 = np.random.randn(2, 4) A21 = np.zeros((5, 3)) A22 = np.random.randn(5, 4) A = np.vstack((np.hstack((A11, A12)), np.hstack((A21, A22)))) A11op = NumpyMatrixOperator(A11) A12op = NumpyMatrixOperator(A12) A22op = NumpyMatrixOperator(A22) Aop = BlockOperator(np.array([[A11op, A12op], [None, A22op]])) v1 = np.random.randn(2) v2 = np.random.randn(5) v = np.hstack((v1, v2)) v1va = NumpyVectorSpace.from_numpy(v1) v2va = NumpyVectorSpace.from_numpy(v2) vva = BlockVectorSpace.make_array((v1va, v2va)) wva = Aop.apply_adjoint(vva) w = np.hstack((wva.block(0).to_numpy(), wva.block(1).to_numpy())) assert np.allclose(A.T.dot(v), w)
def test_real_imag(): A = np.array([[1 + 2j, 3 + 4j], [5 + 6j, 7 + 8j], [9 + 10j, 11 + 12j]]) Ava = NumpyVectorSpace.from_numpy(A) Bva = Ava.real Cva = Ava.imag k = 0 for i in range(3): for j in range(2): k += 1 assert Bva.to_numpy()[i, j] == k k += 1 assert Cva.to_numpy()[i, j] == k
def test_apply_adjoint(): np.random.seed(0) A11 = np.random.randn(2, 3) A12 = np.random.randn(2, 4) A21 = np.zeros((5, 3)) A22 = np.random.randn(5, 4) A = np.vstack((np.hstack((A11, A12)), np.hstack((A21, A22)))) A11op = NumpyMatrixOperator(A11) A12op = NumpyMatrixOperator(A12) A22op = NumpyMatrixOperator(A22) Aop = BlockOperator(np.array([[A11op, A12op], [None, A22op]])) v1 = np.random.randn(2) v2 = np.random.randn(5) v = np.hstack((v1, v2)) v1va = NumpyVectorSpace.from_numpy(v1) v2va = NumpyVectorSpace.from_numpy(v2) vva = BlockVectorSpace.make_array((v1va, v2va)) wva = Aop.apply_adjoint(vva) w = np.hstack((wva.block(0).to_numpy(), wva.block(1).to_numpy())) assert np.allclose(A.T.dot(v), w)
def _newton(order, **kwargs): mop = MonomOperator(order) rhs = NumpyVectorSpace.from_numpy([0.0]) guess = NumpyVectorSpace.from_numpy([1.0]) return newton(mop, rhs, initial_guess=guess, **kwargs)
def _newton(order, **kwargs): mop = MonomOperator(order) rhs = NumpyVectorSpace.from_numpy([0.0]) guess = NumpyVectorSpace.from_numpy([1.0]) return newton(mop, rhs, initial_guess=guess, **kwargs)
def _newton(mop, initial_value=1.0, **kwargs): rhs = NumpyVectorSpace.from_numpy([0.0]) guess = NumpyVectorSpace.from_numpy([initial_value]) return newton(mop, rhs, initial_guess=guess, **kwargs)
class NumpyMatrixOperator(NumpyMatrixBasedOperator): """Wraps a 2D |NumPy Array| as an |Operator|. Parameters ---------- matrix The |NumPy array| which is to be wrapped. source_id The id of the operator's `source` |VectorSpace|. range_id The id of the operator's `range` |VectorSpace|. solver_options The |solver_options| for the operator. name Name of the operator. """ def __init__(self, matrix, source_id=None, range_id=None, solver_options=None, name=None): assert matrix.ndim <= 2 if matrix.ndim == 1: matrix = np.reshape(matrix, (1, -1)) try: matrix.setflags(write=False) # make numpy arrays read-only except AttributeError: pass self.__auto_init(locals()) self.source = NumpyVectorSpace(matrix.shape[1], source_id) self.range = NumpyVectorSpace(matrix.shape[0], range_id) self.sparse = issparse(matrix) @classmethod def from_file(cls, path, key=None, source_id=None, range_id=None, solver_options=None, name=None): from pymor.tools.io import load_matrix matrix = load_matrix(path, key=key) return cls(matrix, solver_options=solver_options, source_id=source_id, range_id=range_id, name=name or key or path) @property def H(self): options = {'inverse': self.solver_options.get('inverse_adjoint'), 'inverse_adjoint': self.solver_options.get('inverse')} if self.solver_options else None if self.sparse: adjoint_matrix = self.matrix.transpose(copy=False).conj(copy=False) elif np.isrealobj(self.matrix): adjoint_matrix = self.matrix.T else: adjoint_matrix = self.matrix.T.conj() return self.with_(matrix=adjoint_matrix, source_id=self.range_id, range_id=self.source_id, solver_options=options, name=self.name + '_adjoint') def _assemble(self, mu=None): pass def assemble(self, mu=None): return self def as_range_array(self, mu=None): if self.sparse: raise NotImplementedError return self.range.from_numpy(self.matrix.T.copy()) def as_source_array(self, mu=None): if self.sparse: raise NotImplementedError return self.source.from_numpy(self.matrix.copy()).conj() def apply(self, U, mu=None): assert U in self.source return self.range.make_array(self.matrix.dot(U.to_numpy().T).T) def apply_adjoint(self, V, mu=None): assert V in self.range return self.H.apply(V, mu=mu) @defaults('check_finite', 'default_sparse_solver_backend') def apply_inverse(self, V, mu=None, initial_guess=None, least_squares=False, check_finite=True, default_sparse_solver_backend='scipy'): """Apply the inverse operator. Parameters ---------- V |VectorArray| of vectors to which the inverse operator is applied. mu The |parameter values| for which to evaluate the inverse operator. initial_guess |VectorArray| with the same length as `V` containing initial guesses for the solution. Some implementations of `apply_inverse` may ignore this parameter. If `None` a solver-dependent default is used. least_squares If `True`, solve the least squares problem:: u = argmin ||op(u) - v||_2. Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate |solver_options| are set for the operator, most implementations will choose a least squares solver by default which may be undesirable. check_finite Test if solution only contains finite values. default_sparse_solver_backend Default sparse solver backend to use (scipy, pyamg, generic). Returns ------- |VectorArray| of the inverse operator evaluations. Raises ------ InversionError The operator could not be inverted. """ assert V in self.range assert initial_guess is None or initial_guess in self.source and len(initial_guess) == len(V) if V.dim == 0: if self.source.dim == 0 or least_squares: return self.source.make_array(np.zeros((len(V), self.source.dim))) else: raise InversionError if self.source.dim != self.range.dim and not least_squares: raise InversionError options = self.solver_options.get('inverse') if self.solver_options else None assert self.sparse or not options if self.sparse: if options: solver = options if isinstance(options, str) else options['type'] backend = solver.split('_')[0] else: backend = default_sparse_solver_backend if backend == 'scipy': from pymor.bindings.scipy import apply_inverse as apply_inverse_impl elif backend == 'pyamg': if not config.HAVE_PYAMG: raise RuntimeError('PyAMG support not enabled.') from pymor.bindings.pyamg import apply_inverse as apply_inverse_impl elif backend == 'generic': logger = getLogger('pymor.bindings.scipy.scipy_apply_inverse') logger.warning('You have selected a (potentially slow) generic solver for a NumPy matrix operator!') from pymor.algorithms.genericsolvers import apply_inverse as apply_inverse_impl else: raise NotImplementedError return apply_inverse_impl(self, V, initial_guess=initial_guess, options=options, least_squares=least_squares, check_finite=check_finite) else: if least_squares: try: R, _, _, _ = np.linalg.lstsq(self.matrix, V.to_numpy().T) except np.linalg.LinAlgError as e: raise InversionError(f'{str(type(e))}: {str(e)}') R = R.T else: try: R = solve(self.matrix, V.to_numpy().T).T except np.linalg.LinAlgError as e: raise InversionError(f'{str(type(e))}: {str(e)}') if check_finite: if not np.isfinite(np.sum(R)): raise InversionError('Result contains non-finite values') return self.source.make_array(R) def apply_inverse_adjoint(self, U, mu=None, initial_guess=None, least_squares=False): return self.H.apply_inverse(U, mu=mu, initial_guess=initial_guess, least_squares=least_squares) def _assemble_lincomb(self, operators, coefficients, identity_shift=0., solver_options=None, name=None): if not all(isinstance(op, NumpyMatrixOperator) for op in operators): return None common_mat_dtype = reduce(np.promote_types, (op.matrix.dtype for op in operators if hasattr(op, 'matrix'))) common_coef_dtype = reduce(np.promote_types, (type(c) for c in coefficients + [identity_shift])) common_dtype = np.promote_types(common_mat_dtype, common_coef_dtype) if coefficients[0] == 1: matrix = operators[0].matrix.astype(common_dtype) else: matrix = operators[0].matrix * coefficients[0] if matrix.dtype != common_dtype: matrix = matrix.astype(common_dtype) for op, c in zip(operators[1:], coefficients[1:]): if c == 1: try: matrix += op.matrix except NotImplementedError: matrix = matrix + op.matrix elif c == -1: try: matrix -= op.matrix except NotImplementedError: matrix = matrix - op.matrix else: try: matrix += (op.matrix * c) except NotImplementedError: matrix = matrix + (op.matrix * c) if identity_shift != 0: if identity_shift.imag == 0: identity_shift = identity_shift.real if operators[0].sparse: try: matrix += (scipy.sparse.eye(matrix.shape[0]) * identity_shift) except NotImplementedError: matrix = matrix + (scipy.sparse.eye(matrix.shape[0]) * identity_shift) else: matrix += (np.eye(matrix.shape[0]) * identity_shift) return NumpyMatrixOperator(matrix, source_id=self.source.id, range_id=self.range.id, solver_options=solver_options) def __getstate__(self): if hasattr(self.matrix, 'factorization'): # remove unplicklable SuperLU factorization del self.matrix.factorization return self.__dict__ def _format_repr(self, max_width, verbosity): if self.sparse: matrix_repr = f'<{self.range.dim}x{self.source.dim} sparse, {self.matrix.nnz} nnz>' else: matrix_repr = f'<{self.range.dim}x{self.source.dim} dense>' return super()._format_repr(max_width, verbosity, override={'matrix': matrix_repr})
def numpy_vector_array_factory(length, dim, seed): np.random.seed(seed) return NumpyVectorSpace.from_numpy(np.random.random((length, dim)))
def test_not_too_many_modes(method): vec_array = NumpyVectorSpace.from_numpy( np.logspace(-5, 0, 10).reshape((-1, 1))) U, s, V = method(vec_array, atol=0, rtol=0) assert len(U) == len(s) == len(V) == 1
def test_dot(): x = NumpyVectorSpace.from_numpy(np.array([1 + 1j])) y = NumpyVectorSpace.from_numpy(np.array([1 - 1j])) z = x.dot(y) assert z[0, 0] == -2j
def test_pairwise_dot(): x = NumpyVectorSpace.from_numpy(np.array([1 + 1j])) y = NumpyVectorSpace.from_numpy(np.array([1 - 1j])) z = x.pairwise_dot(y) assert z == -2j
def test_pairwise_dot(): x = NumpyVectorSpace.from_numpy(np.array([1 + 1j])) y = NumpyVectorSpace.from_numpy(np.array([1 - 1j])) z = x.pairwise_dot(y) assert z == -2j
def test_dot(): x = NumpyVectorSpace.from_numpy(np.array([1 + 1j])) y = NumpyVectorSpace.from_numpy(np.array([1 - 1j])) z = x.dot(y) assert z[0, 0] == -2j