def numpy_list_vector_array_factory(length, dim, seed):
np.random.seed(seed)
if np.random.randint(2):
return NumpyListVectorSpace.from_numpy(np.random.random((length, dim)))
else:
return NumpyListVectorSpace.from_numpy(
np.random.random((length, dim)) +
np.random.random((length, dim)) * 1j)
def __init__(self,
matrix,
source_id=None,
range_id=None,
solver_options=None,
name=None):
super().__init__(matrix,
source_id=source_id,
range_id=range_id,
solver_options=solver_options,
name=name)
self.source = NumpyListVectorSpace(matrix.shape[1], source_id)
self.range = NumpyListVectorSpace(matrix.shape[0], range_id)
def __init__(self, matrix, functional=False, vector=False, source_id=None, range_id=None,
solver_options=None, name=None):
assert not (functional and vector)
super().__init__(matrix, source_id=source_id, range_id=range_id, solver_options=solver_options, name=name)
if vector:
self.source = NumpyVectorSpace(1, source_id)
else:
self.source = NumpyListVectorSpace(matrix.shape[1], source_id)
if functional:
self.range = NumpyVectorSpace(1, range_id)
else:
self.range = NumpyListVectorSpace(matrix.shape[0], range_id)
self.functional = functional
self.vector = vector
def __init__(self, matrix, source_id=None, range_id=None, solver_options=None, name=None):
super().__init__(matrix, source_id=source_id, range_id=range_id, solver_options=solver_options, name=name)
functional = self.range_id is None
vector = self.source_id is None
if functional and vector:
raise NotImplementedError
if vector:
self.source = NumpyVectorSpace(1, source_id)
else:
self.source = NumpyListVectorSpace(matrix.shape[1], source_id)
if functional:
self.range = NumpyVectorSpace(1, range_id)
else:
self.range = NumpyListVectorSpace(matrix.shape[0], range_id)
self.functional = functional
self.vector = vector
def __init__(self,
matrix,
source_id=None,
range_id=None,
solver_options=None,
name=None):
super().__init__(matrix,
source_id=source_id,
range_id=range_id,
solver_options=solver_options,
name=name)
functional = self.range_id is None
vector = self.source_id is None
if functional and vector:
raise NotImplementedError
if vector:
self.source = NumpyVectorSpace(1, source_id)
else:
self.source = NumpyListVectorSpace(matrix.shape[1], source_id)
if functional:
self.range = NumpyVectorSpace(1, range_id)
else:
self.range = NumpyListVectorSpace(matrix.shape[0], range_id)
self.functional = functional
self.vector = vector
def action_NumpyMatrixOperator(self, op):
vector = op.source.dim == 1
functional = op.range.dim == 1
if vector and functional:
raise NotImplementedError
if vector:
space = NumpyListVectorSpace(op.range.dim, op.range.id)
return VectorOperator(space.from_numpy(op.matrix.reshape((1, -1))), op.name)
elif functional:
space = NumpyListVectorSpace(op.source.dim, op.source.id)
return VectorFunctional(space.from_numpy(op.matrix.ravel()), op.name)
else:
return op.with_(new_type=NumpyListVectorArrayMatrixOperator)
def action_VectorArrayOperator(self, op):
space = NumpyListVectorSpace(op.array.dim, op.array.space.id)
return op.with_(new_type=VectorArrayOperator,
array=space.from_numpy(op.array.to_numpy()))
def _numpy_list_vector_spaces(draw, np_data_list, compatible, count, dims):
return [(NumpyListVectorSpace(d), ar) for d, ar in zip(dims, np_data_list)]
class NumpyListVectorArrayMatrixOperator(NumpyMatrixOperator):
"""Variant of |NumpyMatrixOperator| using |ListVectorArray| instead of |NumpyVectorArray|."""
def __init__(self, matrix, source_id=None, range_id=None, solver_options=None, name=None):
super().__init__(matrix, source_id=source_id, range_id=range_id, solver_options=solver_options, name=name)
functional = self.range_id is None
vector = self.source_id is None
if functional and vector:
raise NotImplementedError
if vector:
self.source = NumpyVectorSpace(1, source_id)
else:
self.source = NumpyListVectorSpace(matrix.shape[1], source_id)
if functional:
self.range = NumpyVectorSpace(1, range_id)
else:
self.range = NumpyListVectorSpace(matrix.shape[0], range_id)
self.functional = functional
self.vector = vector
def apply(self, U, mu=None):
assert U in self.source
if self.vector:
V = super().apply(U, mu=mu)
return self.range.from_numpy(V.to_numpy())
V = [self.matrix.dot(v._array) for v in U._list]
if self.functional:
return self.range.make_array(np.array(V)) if len(V) > 0 else self.range.empty()
else:
return self.range.make_array(V)
def apply_adjoint(self, V, mu=None):
assert V in self.range
if self.functional:
U = super().apply_adjoint(V, mu=mu)
return self.source.from_numpy(U.to_numpy())
adj_op = NumpyMatrixOperator(self.matrix).H
U = [adj_op.apply(adj_op.source.make_array(v._array)).to_numpy().ravel() for v in V._list]
if self.vector:
return self.source.make_array(np.array(U)) if len(U) > 0 else self.source.empty()
else:
return self.source.from_numpy(U)
def apply_inverse(self, V, mu=None, least_squares=False):
assert V in self.range
assert not self.functional and not self.vector
if V.dim == 0:
if self.source.dim == 0 and least_squares:
return self.source.make_array([np.zeros(0) for _ in range(len(V))])
else:
raise InversionError
op = NumpyMatrixOperator(self.matrix, solver_options=self.solver_options)
return self.source.make_array([op.apply_inverse(NumpyVectorSpace.make_array(v._array),
least_squares=least_squares).to_numpy().ravel()
for v in V._list])
def as_range_array(self, mu=None):
assert not self.sparse
return self.range.make_array(list(self.matrix.T.copy()))
def as_source_array(self, mu=None):
assert not self.sparse
return self.source.make_array(list(self.matrix.copy()))
def _assemble_lincomb(self, operators, coefficients, identity_shift=0., solver_options=None, name=None):
lincomb = super()._assemble_lincomb(operators, coefficients, identity_shift)
if lincomb is None:
return None
else:
return NumpyListVectorArrayMatrixOperator(lincomb.matrix, source_id=self.source.id, range_id=self.range.id,
solver_options=solver_options, name=name)
def numpy_list_vector_array_factory(length, dim, seed):
np.random.seed(seed)
return NumpyListVectorSpace.from_numpy(np.random.random((length, dim)))