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
