pymor.vectorarrays package¶
Submodules¶
block module¶

class
pymor.vectorarrays.block.
BlockVectorArray
(blocks, space)[source]¶ Bases:
pymor.vectorarrays.interface.VectorArray
VectorArray
where each vector is a direct sum of subvectors.Given a list of equal length
VectorArrays
blocks
, thisVectorArray
represents the direct sums of the vectors contained in the arrays. The associatedVectorSpace
isBlockVectorSpace
.BlockVectorArray
can be used in conjunction withBlockOperator
.Methods
amax
,append
,axpy
,block
,conj
,copy
,dofs
,inner
,lincomb
,pairwise_inner
,scal
,sup_norm
,to_numpy
check_ind
,check_ind_unique
,dot
,empty
,full
,gramian
,l2_norm
,l2_norm2
,len_ind
,len_ind_unique
,norm
,norm2
,normalize_ind
,ones
,pairwise_dot
,random
,sub_index
,zeros
Attributes

__getitem__
(ind)[source]¶ Return a
VectorArray
view onto a subset of the vectors in the array.

amax
()[source]¶ The maximum absolute value of the DOFs contained in the array.
Returns
 max_ind
NumPy array
containing for each vector a DOF index at which the maximum is attained. max_val
NumPy array
containing for each vector the maximum absolute value of its DOFs.

append
(other, remove_from_other=False)[source]¶ Append vectors to the array.
Parameters
 other
A
VectorArray
containing the vectors to be appended. remove_from_other
If
True
, the appended vectors are removed fromother
. For listlike implementations this can be used to prevent unnecessary copies of the involved vectors.

axpy
(alpha, x)[source]¶ BLAS AXPY operation.
This method forms the sum
self = alpha*x + self
If the length of
x
is 1, the samex
vector is used for all vectors inself
. Otherwise, the lengths ofself
andx
have to agree. Ifalpha
is a scalar, eachx
vector is multiplied with the same factoralpha
. Otherwise,alpha
has to be a onedimensionalNumPy array
of the same length asself
containing the coefficients for eachx
vector.Parameters
 alpha
The scalar coefficient or onedimensional
NumPy array
of coefficients with which the vectors inx
are multiplied. x
A
VectorArray
containing the xsummands.

copy
(deep=False)[source]¶ Returns a copy of the array.
All
VectorArray
implementations in pyMOR have copyonwrite semantics: if not specified otherwise by settingdeep
toTrue
, the returned copy will hold a handle to the same array data as the original array, and a deep copy of the data will only be performed when one of the arrays is modified.Note that for
NumpyVectorArray
, a deep copy is always performed when only some vectors in the array are copied.Parameters
 deep
Ensure that an actual copy of the array data is made (see above).
Returns
A copy of the
VectorArray
.

dofs
(dof_indices)[source]¶ Extract DOFs of the vectors contained in the array.
Parameters
 dof_indices
List or 1D
NumPy array
of indices of the DOFs that are to be returned.
Returns
A
NumPy array
result
such thatresult[i, j]
is thedof_indices[j]
th DOF of thei
th vector of the array.

property
imag
¶ Imaginary part.

inner
(other, product=None)[source]¶ Returns the inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.inner(V)
is equivalent to:
U.dofs(np.arange(U.dim)) @ V.dofs(np.arange(V.dim)).T
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingapply2
, i.e.U.inner(V, product)
is equivalent to:product.apply2(U, V)
which in turn is, by default, implemented as:
U.inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.

lincomb
(coefficients)[source]¶ Returns linear combinations of the vectors contained in the array.
Parameters
 coefficients
A
NumPy array
of dimension 1 or 2 containing the linear coefficients.coefficients.shape[1]
has to agree withlen(self)
.
Returns
A
VectorArray
result
such thatresult[i] = ∑ self[j] * coefficients[i,j]
in case
coefficients
is of dimension 2, otherwiselen(result) == 1
andresult[0] = ∑ self[j] * coefficients[j].

pairwise_inner
(other, product=None)[source]¶ Returns the pairwise inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.pairwise_inner(V)
is equivalent to:
np.sum(U.dofs(np.arange(U.dim)) * V.dofs(np.arange(V.dim)), axis=1)
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingpairwise_apply2
, i.e.U.inner(V, product)
is equivalent to:product.pairwise_apply2(U, V)
which in turn is, by default, implemented as:
U.pairwise_inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.

property
real
¶ Real part.

scal
(alpha)[source]¶ BLAS SCAL operation (inplace scalar multiplication).
This method calculates
self = alpha*self
If
alpha
is a scalar, each vector is multiplied by this scalar. Otherwise,alpha
has to be a onedimensionalNumPy array
of the same length asself
containing the factors for each vector.Parameters
 alpha
The scalar coefficient or onedimensional
NumPy array
of coefficients with which the vectors inself
are multiplied.

sup_norm
()[source]¶ The linfinitynorms of the vectors contained in the array.
Returns
A
NumPy array
result
such thatresult[i]
contains the norm ofself[i]
.

to_numpy
(ensure_copy=False)[source]¶ Return (len(self), self.dim) NumPy Array with the data stored in the array.
Parameters
 ensure_copy
If
False
, modifying the returnedNumPy array
might alter the originalVectorArray
. IfTrue
always a copy of the array data is made.


class
pymor.vectorarrays.block.
BlockVectorArrayView
(base, ind)[source]¶ Bases:
pymor.vectorarrays.block.BlockVectorArray
Methods
amax
,append
,axpy
,block
,conj
,copy
,dofs
,inner
,lincomb
,pairwise_inner
,scal
,sup_norm
,to_numpy
check_ind
,check_ind_unique
,dot
,empty
,full
,gramian
,l2_norm
,l2_norm2
,len_ind
,len_ind_unique
,norm
,norm2
,normalize_ind
,ones
,pairwise_dot
,random
,sub_index
,zeros
Attributes

class
pymor.vectorarrays.block.
BlockVectorSpace
(*args, **kwargs)[source]¶ Bases:
pymor.vectorarrays.interface.VectorSpace
VectorSpace
ofBlockVectorArrays
.A
BlockVectorSpace
is defined by theVectorSpaces
of the individual subblocks which constitute a given array. In particular for a given :class`BlockVectorArray`U
, we have the identity(U.blocks[0].space, U.blocks[1].space, ..., U.blocks[1].space) == U.space.
Parameters
 subspaces
The tuple defined above.
Methods
from_numpy
,make_array
,make_block_diagonal_array
,zeros
Attributes

from_numpy
(data, ensure_copy=False)[source]¶ Create a
VectorArray
from aNumPy array
Note that this method will not be supported by all vector space implementations.
Parameters
 data
NumPy
array of shape(len, dim)
wherelen
is the number of vectors anddim
their dimension. ensure_copy
If
False
, modifying the returnedVectorArray
might alter the originalNumPy array
. IfTrue
always a copy of the array data is made.
Returns
A
VectorArray
withdata
as data.

zeros
(count=1, reserve=0)[source]¶ Create a
VectorArray
of null vectorsParameters
 count
The number of vectors.
 reserve
Hint for the backend to which length the array will grow.
Returns
A
VectorArray
containingcount
vectors with each component zero.
constructions module¶

pymor.vectorarrays.constructions.
cat_arrays
(vector_arrays)[source]¶ Return a new
VectorArray
which is a concatenation of the arrays invector_arrays
.
interface module¶

class
pymor.vectorarrays.interface.
VectorArray
[source]¶ Bases:
pymor.core.base.BasicObject
Interface for vector arrays.
A vector array should be thought of as a list of (possibly highdimensional) vectors. While the vectors themselves will be inaccessible in general (e.g. because they are managed by an external PDE solver code), operations on the vectors like addition can be performed via this interface.
It is assumed that the number of vectors is small enough such that scalar data associated to each vector can be handled on the Python side. As such, methods like
norm
orgramian
will always returnNumPy arrays
.An implementation of the
VectorArray
viaNumPy arrays
is given byNumpyVectorArray
. In general, it is the implementors decision how memory is allocated internally (e.g. continuous block of memory vs. list of pointers to the individual vectors.) Thus, no general assumptions can be made on the costs of operations like appending to or removing vectors from the array. As a hint for ‘continuous block of memory’ implementations,zeros
provides areserve
keyword argument which allows to specify to what size the array is assumed to grow.As with
NumPy array
,VectorArrays
can be indexed with numbers, slices and lists or onedimensionalNumPy arrays
. Indexing will always return a newVectorArray
which acts as a view into the original data. Thus, if the indexed array is modified viascal
oraxpy
, the vectors in the original array will be changed. Indices may be negative, in which case the vector is selected by counting from the end of the array. Moreover indices can be repeated, in which case the corresponding vector is selected several times. The resulting view will be immutable, however.Note
It is disallowed to append vectors to a
VectorArray
view or to remove vectors from it. Removing vectors from an array with existing views will lead to undefined behavior of these views. As such, it is generally advisable to make acopy
of a view for long term storage. Sincecopy
has copyonwrite semantics, this will usually cause little overhead.Methods
amax
,append
,axpy
,check_ind
,check_ind_unique
,conj
,copy
,dofs
,dot
,empty
,full
,gramian
,inner
,l2_norm
,l2_norm2
,len_ind
,len_ind_unique
,lincomb
,norm
,norm2
,normalize_ind
,ones
,pairwise_dot
,pairwise_inner
,random
,scal
,sub_index
,sup_norm
,to_numpy
,zeros
,__delitem__
,__getitem__
,__len__
Attributes

dim
¶ The dimension of the vectors in the array.

is_view
¶ True
if the array is a view obtained by indexing another array.

space
¶ The
VectorSpace
the array belongs to.

abstract
__getitem__
(ind)[source]¶ Return a
VectorArray
view onto a subset of the vectors in the array.

abstract
amax
()[source]¶ The maximum absolute value of the DOFs contained in the array.
Returns
 max_ind
NumPy array
containing for each vector a DOF index at which the maximum is attained. max_val
NumPy array
containing for each vector the maximum absolute value of its DOFs.

abstract
append
(other, remove_from_other=False)[source]¶ Append vectors to the array.
Parameters
 other
A
VectorArray
containing the vectors to be appended. remove_from_other
If
True
, the appended vectors are removed fromother
. For listlike implementations this can be used to prevent unnecessary copies of the involved vectors.

abstract
axpy
(alpha, x)[source]¶ BLAS AXPY operation.
This method forms the sum
self = alpha*x + self
If the length of
x
is 1, the samex
vector is used for all vectors inself
. Otherwise, the lengths ofself
andx
have to agree. Ifalpha
is a scalar, eachx
vector is multiplied with the same factoralpha
. Otherwise,alpha
has to be a onedimensionalNumPy array
of the same length asself
containing the coefficients for eachx
vector.Parameters
 alpha
The scalar coefficient or onedimensional
NumPy array
of coefficients with which the vectors inx
are multiplied. x
A
VectorArray
containing the xsummands.

check_ind
(ind)[source]¶ Check if
ind
is an admissible list of indices in the sense of the class documentation.

check_ind_unique
(ind)[source]¶ Check if
ind
is an admissible list of nonrepeated indices in the sense of the class documentation.

abstract
copy
(deep=False)[source]¶ Returns a copy of the array.
All
VectorArray
implementations in pyMOR have copyonwrite semantics: if not specified otherwise by settingdeep
toTrue
, the returned copy will hold a handle to the same array data as the original array, and a deep copy of the data will only be performed when one of the arrays is modified.Note that for
NumpyVectorArray
, a deep copy is always performed when only some vectors in the array are copied.Parameters
 deep
Ensure that an actual copy of the array data is made (see above).
Returns
A copy of the
VectorArray
.

abstract
dofs
(dof_indices)[source]¶ Extract DOFs of the vectors contained in the array.
Parameters
 dof_indices
List or 1D
NumPy array
of indices of the DOFs that are to be returned.
Returns
A
NumPy array
result
such thatresult[i, j]
is thedof_indices[j]
th DOF of thei
th vector of the array.

empty
(reserve=0)[source]¶ Create an empty
VectorArray
of the sameVectorSpace
.This is a shorthand for
self.space.zeros(0, reserve)
.Parameters
 reserve
Hint for the backend to which length the array will grow.
Returns
An empty
VectorArray
.

full
(value, count=1, reserve=0)[source]¶ Create a
VectorArray
of vectors with all DOFs set to the same value.This is a shorthand for
self.space.full(value, count, reserve)
.Parameters
 value
The value each DOF should be set to.
 count
The number of vectors.
 reserve
Hint for the backend to which length the array will grow.
Returns
A
VectorArray
containingcount
vectors with each DOF set tovalue
.

property
imag
¶ Imaginary part.

inner
(other, product=None)[source]¶ Returns the inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.inner(V)
is equivalent to:
U.dofs(np.arange(U.dim)) @ V.dofs(np.arange(V.dim)).T
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingapply2
, i.e.U.inner(V, product)
is equivalent to:product.apply2(U, V)
which in turn is, by default, implemented as:
U.inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.

abstract
lincomb
(coefficients)[source]¶ Returns linear combinations of the vectors contained in the array.
Parameters
 coefficients
A
NumPy array
of dimension 1 or 2 containing the linear coefficients.coefficients.shape[1]
has to agree withlen(self)
.
Returns
A
VectorArray
result
such thatresult[i] = ∑ self[j] * coefficients[i,j]
in case
coefficients
is of dimension 2, otherwiselen(result) == 1
andresult[0] = ∑ self[j] * coefficients[j].

norm
(product=None, tol=None, raise_complex=None)[source]¶ Norm with respect to a given inner product.
If
product
isNone
, the Euclidean norms of thedofs
of the array are returned, i.e.U.norm()
is equivalent to:
np.sqrt(U.pairwise_inner(U))
If a
product
Operator
is specified, thisOperator
is used to compute the norms via:np.sqrt(product.pairwise_apply2(U, U))
Parameters
 product
If not
None
, the inner productOperator
used to compute the norms. tol
If
raise_complex
isTrue
, aValueError
exception is raised if there are complex norm squares with an imaginary part of absolute value larger thantol
. raise_complex
See
tol
.
Returns
A onedimensional
NumPy array
of the norms of the vectors in the array.

norm2
(product=None, tol=1e10, raise_complex=True)[source]¶ Squared norm with respect to a given inner product.
If
product
isNone
, the Euclidean norms of thedofs
of the array are returned, i.e.U.norm()
is equivalent to:
U.pairwise_inner(U)
If a
product
Operator
is specified, thisOperator
is used to compute the norms via:product.pairwise_apply2(U, U)
Parameters
 product
If not
None
, the inner productOperator
used to compute the norms. tol
If
raise_complex
isTrue
, aValueError
exception is raised if there are complex norm squares with an imaginary part of absolute value larger thantol
. raise_complex
See
tol
.
Returns
A onedimensional
NumPy array
of the squared norms of the vectors in the array.Defaults
tol, raise_complex (see
pymor.core.defaults
)

normalize_ind
(ind)[source]¶ Normalize given indices such that they are independent of the array length.

ones
(count=1, reserve=0)[source]¶ Create a
VectorArray
of vectors of the sameVectorSpace
with all DOFs set to one.This is a shorthand for
self.space.full(1., count, reserve)
.Parameters
 count
The number of vectors.
 reserve
Hint for the backend to which length the array will grow.
Returns
A
VectorArray
containingcount
vectors with each DOF set to one.

pairwise_inner
(other, product=None)[source]¶ Returns the pairwise inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.pairwise_inner(V)
is equivalent to:
np.sum(U.dofs(np.arange(U.dim)) * V.dofs(np.arange(V.dim)), axis=1)
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingpairwise_apply2
, i.e.U.inner(V, product)
is equivalent to:product.pairwise_apply2(U, V)
which in turn is, by default, implemented as:
U.pairwise_inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.

random
(count=1, distribution='uniform', random_state=None, seed=None, reserve=0, **kwargs)[source]¶ Create a
VectorArray
of vectors with random entries.This is a shorthand for
self.space.random(count, distribution, radom_state, seed, **kwargs)
.Supported random distributions:
'uniform': Uniform distribution in halfopen interval [`low`, `high`). 'normal': Normal (Gaussian) distribution with mean `loc` and standard deviation `scale`.
Note that not all random distributions are necessarily implemented by all
VectorSpace
implementations.Parameters
 count
The number of vectors.
 distribution
Random distribution to use (
'uniform'
,'normal'
). low
Lower bound for
'uniform'
distribution (defaults to0
). high
Upper bound for
'uniform'
distribution (defaults to1
). loc
Mean for
'normal'
distribution (defaults to0
). scale
Standard deviation for
'normal'
distribution (defaults to1
). random_state
RandomState
to use for sampling. IfNone
, a new random state is generated usingseed
as random seed, or thedefault
random state is used. seed
If not
None
, a new radom state with this seed is used. reserve
Hint for the backend to which length the array will grow.

property
real
¶ Real part.

abstract
scal
(alpha)[source]¶ BLAS SCAL operation (inplace scalar multiplication).
This method calculates
self = alpha*self
If
alpha
is a scalar, each vector is multiplied by this scalar. Otherwise,alpha
has to be a onedimensionalNumPy array
of the same length asself
containing the factors for each vector.Parameters
 alpha
The scalar coefficient or onedimensional
NumPy array
of coefficients with which the vectors inself
are multiplied.

sup_norm
()[source]¶ The linfinitynorms of the vectors contained in the array.
Returns
A
NumPy array
result
such thatresult[i]
contains the norm ofself[i]
.

to_numpy
(ensure_copy=False)[source]¶ Return (len(self), self.dim) NumPy Array with the data stored in the array.
Parameters
 ensure_copy
If
False
, modifying the returnedNumPy array
might alter the originalVectorArray
. IfTrue
always a copy of the array data is made.

zeros
(count=1, reserve=0)[source]¶ Create a
VectorArray
of null vectors of the sameVectorSpace
.This is a shorthand for
self.space.zeros(count, reserve)
.Parameters
 count
The number of vectors.
 reserve
Hint for the backend to which length the array will grow.
Returns
A
VectorArray
containingcount
vectors with each DOF set to zero.


class
pymor.vectorarrays.interface.
VectorSpace
(*args, **kwargs)[source]¶ Bases:
pymor.core.base.ImmutableObject
Class describing a vector space.
Vector spaces act as factories for
VectorArrays
of vectors contained in them. As such, they hold all data necessary to createVectorArrays
of a given type (e.g. the dimension of the vectors, or a socket for communication with an external PDE solver).New
VectorArrays
of null vectors are created viazeros
. Themake_array
method builds a newVectorArray
from given raw data of the underlying linear algebra backend (e.g. aNumPy array
in the case ofNumpyVectorSpace
). Some vector spaces can create newVectorArrays
from a givenNumPy array
via thefrom_numpy
method.Each vector space has a string
id
to distinguish mathematically different spaces appearing in the formulation of a given problem.Vector spaces can be compared for equality via the
==
and!=
operators. To test if a givenVectorArray
is an element of the space, thein
operator can be used.Methods
empty
,from_numpy
,full
,make_array
,ones
,random
,zeros
Attributes

id
¶ None, or a string describing the mathematical identity of the vector space (for instance to distinguish different components in an equation system).

dim
¶ The dimension (number of degrees of freedom) of the vectors contained in the space.

is_scalar
¶ Equivalent to
isinstance(space, NumpyVectorSpace) and space.dim == 1 and space.id is None
.

empty
(reserve=0)[source]¶ Create an empty
VectorArray
This is a shorthand for
self.zeros(0, reserve)
.Parameters
 reserve
Hint for the backend to which length the array will grow.
Returns
An empty
VectorArray
.

from_numpy
(data, ensure_copy=False)[source]¶ Create a
VectorArray
from aNumPy array
Note that this method will not be supported by all vector space implementations.
Parameters
 data
NumPy
array of shape(len, dim)
wherelen
is the number of vectors anddim
their dimension. ensure_copy
If
False
, modifying the returnedVectorArray
might alter the originalNumPy array
. IfTrue
always a copy of the array data is made.
Returns
A
VectorArray
withdata
as data.

full
(value, count=1, reserve=0)[source]¶ Create a
VectorArray
of vectors with all DOFs set to the same value.Parameters
 value
The value each DOF should be set to.
 count
The number of vectors.
 reserve
Hint for the backend to which length the array will grow.
Returns
A
VectorArray
containingcount
vectors with each DOF set tovalue
.

abstract
make_array
(**kwargs)[source]¶ Create a
VectorArray
from raw data.This method is used in the implementation of
Operators
andModels
to create newVectorArrays
from raw data of the underlying solver backends. The ownership of the data is transferred to the newly created array.The exact signature of this method depends on the wrapped solver backend.

ones
(count=1, reserve=0)[source]¶ Create a
VectorArray
of vectors with all DOFs set to one.This is a shorthand for
self.full(1., count, reserve)
.Parameters
 count
The number of vectors.
 reserve
Hint for the backend to which length the array will grow.
Returns
A
VectorArray
containingcount
vectors with each DOF set to one.

random
(count=1, distribution='uniform', random_state=None, seed=None, reserve=0, **kwargs)[source]¶ Create a
VectorArray
of vectors with random entries.Supported random distributions:
'uniform': Uniform distribution in halfopen interval [`low`, `high`). 'normal': Normal (Gaussian) distribution with mean `loc` and standard deviation `scale`.
Note that not all random distributions are necessarily implemented by all
VectorSpace
implementations.Parameters
 count
The number of vectors.
 distribution
Random distribution to use (
'uniform'
,'normal'
). low
Lower bound for
'uniform'
distribution (defaults to0
). high
Upper bound for
'uniform'
distribution (defaults to1
). loc
Mean for
'normal'
distribution (defaults to0
). scale
Standard deviation for
'normal'
distribution (defaults to1
). random_state
RandomState
to use for sampling. IfNone
, a new random state is generated usingseed
as random seed, or thedefault
random state is used. seed
If not
None
, a new random state with this seed is used. reserve
Hint for the backend to which length the array will grow.

abstract
zeros
(count=1, reserve=0)[source]¶ Create a
VectorArray
of null vectorsParameters
 count
The number of vectors.
 reserve
Hint for the backend to which length the array will grow.
Returns
A
VectorArray
containingcount
vectors with each component zero.

list module¶

class
pymor.vectorarrays.list.
ComplexifiedListVectorSpace
(*args, **kwargs)[source]¶ Bases:
pymor.vectorarrays.list.ListVectorSpace
Methods
full_vector
,make_vector
,random_vector
,real_full_vector
,real_make_vector
,real_random_vector
,real_vector_from_numpy
,real_zero_vector
,vector_from_numpy
,zero_vector
from_numpy
,full
,make_array
,ones
,ones_vector
,random
,space_from_dim
,space_from_vector_obj
,zeros
Attributes

complexified_vector_type
¶ alias of
ComplexifiedVector


class
pymor.vectorarrays.list.
ComplexifiedVector
(real_part, imag_part)[source]¶ Bases:
pymor.vectorarrays.list.Vector
Methods
amax
,axpy
,conj
,copy
,dofs
,inner
,norm
,norm2
,scal
,sup_norm
,to_numpy
Attributes
imag
,real

class
pymor.vectorarrays.list.
CopyOnWriteVector
[source]¶ Bases:
pymor.vectorarrays.list.Vector
Methods
axpy
,copy
,from_instance
,scal
amax
,conj
,dofs
,inner
,norm
,norm2
,sup_norm
Attributes
imag
,real

class
pymor.vectorarrays.list.
ListVectorArray
(vectors, space)[source]¶ Bases:
pymor.vectorarrays.interface.VectorArray
VectorArray
implemented as a Python list of vectors.This
VectorArray
implementation is the first choice when creating pyMOR wrappers for external solvers which are based on single vector objects. In order to do so, a wrapping subclass ofVector
has to be provided on which the implementation ofListVectorArray
will operate. The associatedVectorSpace
is a subclass ofListVectorSpace
.For an example, see
NumpyVector
,NumpyListVectorSpace
orFenicsVector
,FenicsVectorSpace
.Methods
amax
,append
,axpy
,conj
,copy
,dofs
,gramian
,inner
,lincomb
,pairwise_inner
,scal
,sup_norm
,to_numpy
check_ind
,check_ind_unique
,dot
,empty
,full
,l2_norm
,l2_norm2
,len_ind
,len_ind_unique
,norm
,norm2
,normalize_ind
,ones
,pairwise_dot
,random
,sub_index
,zeros
Attributes

__getitem__
(ind)[source]¶ Return a
VectorArray
view onto a subset of the vectors in the array.

property
_data
¶ Return list of NumPy Array views on vector data for hacking / interactive use.

amax
()[source]¶ The maximum absolute value of the DOFs contained in the array.
Returns
 max_ind
NumPy array
containing for each vector a DOF index at which the maximum is attained. max_val
NumPy array
containing for each vector the maximum absolute value of its DOFs.

append
(other, remove_from_other=False)[source]¶ Append vectors to the array.
Parameters
 other
A
VectorArray
containing the vectors to be appended. remove_from_other
If
True
, the appended vectors are removed fromother
. For listlike implementations this can be used to prevent unnecessary copies of the involved vectors.

axpy
(alpha, x)[source]¶ BLAS AXPY operation.
This method forms the sum
self = alpha*x + self
If the length of
x
is 1, the samex
vector is used for all vectors inself
. Otherwise, the lengths ofself
andx
have to agree. Ifalpha
is a scalar, eachx
vector is multiplied with the same factoralpha
. Otherwise,alpha
has to be a onedimensionalNumPy array
of the same length asself
containing the coefficients for eachx
vector.Parameters
 alpha
The scalar coefficient or onedimensional
NumPy array
of coefficients with which the vectors inx
are multiplied. x
A
VectorArray
containing the xsummands.

copy
(deep=False)[source]¶ Returns a copy of the array.
All
VectorArray
implementations in pyMOR have copyonwrite semantics: if not specified otherwise by settingdeep
toTrue
, the returned copy will hold a handle to the same array data as the original array, and a deep copy of the data will only be performed when one of the arrays is modified.Note that for
NumpyVectorArray
, a deep copy is always performed when only some vectors in the array are copied.Parameters
 deep
Ensure that an actual copy of the array data is made (see above).
Returns
A copy of the
VectorArray
.

dofs
(dof_indices)[source]¶ Extract DOFs of the vectors contained in the array.
Parameters
 dof_indices
List or 1D
NumPy array
of indices of the DOFs that are to be returned.
Returns
A
NumPy array
result
such thatresult[i, j]
is thedof_indices[j]
th DOF of thei
th vector of the array.

property
imag
¶ Imaginary part.

inner
(other, product=None)[source]¶ Returns the inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.inner(V)
is equivalent to:
U.dofs(np.arange(U.dim)) @ V.dofs(np.arange(V.dim)).T
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingapply2
, i.e.U.inner(V, product)
is equivalent to:product.apply2(U, V)
which in turn is, by default, implemented as:
U.inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.

lincomb
(coefficients)[source]¶ Returns linear combinations of the vectors contained in the array.
Parameters
 coefficients
A
NumPy array
of dimension 1 or 2 containing the linear coefficients.coefficients.shape[1]
has to agree withlen(self)
.
Returns
A
VectorArray
result
such thatresult[i] = ∑ self[j] * coefficients[i,j]
in case
coefficients
is of dimension 2, otherwiselen(result) == 1
andresult[0] = ∑ self[j] * coefficients[j].

pairwise_inner
(other, product=None)[source]¶ Returns the pairwise inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.pairwise_inner(V)
is equivalent to:
np.sum(U.dofs(np.arange(U.dim)) * V.dofs(np.arange(V.dim)), axis=1)
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingpairwise_apply2
, i.e.U.inner(V, product)
is equivalent to:product.pairwise_apply2(U, V)
which in turn is, by default, implemented as:
U.pairwise_inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.

property
real
¶ Real part.

scal
(alpha)[source]¶ BLAS SCAL operation (inplace scalar multiplication).
This method calculates
self = alpha*self
If
alpha
is a scalar, each vector is multiplied by this scalar. Otherwise,alpha
has to be a onedimensionalNumPy array
of the same length asself
containing the factors for each vector.Parameters
 alpha
The scalar coefficient or onedimensional
NumPy array
of coefficients with which the vectors inself
are multiplied.

sup_norm
()[source]¶ The linfinitynorms of the vectors contained in the array.
Returns
A
NumPy array
result
such thatresult[i]
contains the norm ofself[i]
.

to_numpy
(ensure_copy=False)[source]¶ Return (len(self), self.dim) NumPy Array with the data stored in the array.
Parameters
 ensure_copy
If
False
, modifying the returnedNumPy array
might alter the originalVectorArray
. IfTrue
always a copy of the array data is made.


class
pymor.vectorarrays.list.
ListVectorArrayView
(base, ind)[source]¶ Bases:
pymor.vectorarrays.list.ListVectorArray
Methods
amax
,conj
,copy
,dofs
,gramian
,inner
,lincomb
,pairwise_inner
,sup_norm
,to_numpy
check_ind
,check_ind_unique
,dot
,empty
,full
,l2_norm
,l2_norm2
,len_ind
,len_ind_unique
,norm
,norm2
,normalize_ind
,ones
,pairwise_dot
,random
,sub_index
,zeros
Attributes

__getitem__
(ind)[source]¶ Return a
VectorArray
view onto a subset of the vectors in the array.

append
(other, remove_from_other=False)[source]¶ Append vectors to the array.
Parameters
 other
A
VectorArray
containing the vectors to be appended. remove_from_other
If
True
, the appended vectors are removed fromother
. For listlike implementations this can be used to prevent unnecessary copies of the involved vectors.

axpy
(alpha, x)[source]¶ BLAS AXPY operation.
This method forms the sum
self = alpha*x + self
If the length of
x
is 1, the samex
vector is used for all vectors inself
. Otherwise, the lengths ofself
andx
have to agree. Ifalpha
is a scalar, eachx
vector is multiplied with the same factoralpha
. Otherwise,alpha
has to be a onedimensionalNumPy array
of the same length asself
containing the coefficients for eachx
vector.Parameters
 alpha
The scalar coefficient or onedimensional
NumPy array
of coefficients with which the vectors inx
are multiplied. x
A
VectorArray
containing the xsummands.

scal
(alpha)[source]¶ BLAS SCAL operation (inplace scalar multiplication).
This method calculates
self = alpha*self
If
alpha
is a scalar, each vector is multiplied by this scalar. Otherwise,alpha
has to be a onedimensionalNumPy array
of the same length asself
containing the factors for each vector.Parameters
 alpha
The scalar coefficient or onedimensional
NumPy array
of coefficients with which the vectors inself
are multiplied.


class
pymor.vectorarrays.list.
ListVectorSpace
(*args, **kwargs)[source]¶ Bases:
pymor.vectorarrays.interface.VectorSpace
VectorSpace
ofListVectorArrays
.Methods
from_numpy
,full
,full_vector
,make_array
,make_vector
,ones
,ones_vector
,random
,random_vector
,space_from_dim
,space_from_vector_obj
,vector_from_numpy
,zero_vector
,zeros
Attributes

full
(value, count=1, reserve=0)[source]¶ Create a
VectorArray
of vectors with all DOFs set to the same value.Parameters
 value
The value each DOF should be set to.
 count
The number of vectors.
 reserve
Hint for the backend to which length the array will grow.
Returns
A
VectorArray
containingcount
vectors with each DOF set tovalue
.

ones
(count=1, reserve=0)[source]¶ Create a
VectorArray
of vectors with all DOFs set to one.This is a shorthand for
self.full(1., count, reserve)
.Parameters
 count
The number of vectors.
 reserve
Hint for the backend to which length the array will grow.
Returns
A
VectorArray
containingcount
vectors with each DOF set to one.

random
(count=1, distribution='uniform', random_state=None, seed=None, reserve=0, **kwargs)[source]¶ Create a
VectorArray
of vectors with random entries.Supported random distributions:
'uniform': Uniform distribution in halfopen interval [`low`, `high`). 'normal': Normal (Gaussian) distribution with mean `loc` and standard deviation `scale`.
Note that not all random distributions are necessarily implemented by all
VectorSpace
implementations.Parameters
 count
The number of vectors.
 distribution
Random distribution to use (
'uniform'
,'normal'
). low
Lower bound for
'uniform'
distribution (defaults to0
). high
Upper bound for
'uniform'
distribution (defaults to1
). loc
Mean for
'normal'
distribution (defaults to0
). scale
Standard deviation for
'normal'
distribution (defaults to1
). random_state
RandomState
to use for sampling. IfNone
, a new random state is generated usingseed
as random seed, or thedefault
random state is used. seed
If not
None
, a new random state with this seed is used. reserve
Hint for the backend to which length the array will grow.

zeros
(count=1, reserve=0)[source]¶ Create a
VectorArray
of null vectorsParameters
 count
The number of vectors.
 reserve
Hint for the backend to which length the array will grow.
Returns
A
VectorArray
containingcount
vectors with each component zero.


class
pymor.vectorarrays.list.
NumpyListVectorSpace
(*args, **kwargs)[source]¶ Bases:
pymor.vectorarrays.list.ListVectorSpace
Methods
full_vector
,make_vector
,ones_vector
,space_from_dim
,space_from_vector_obj
,vector_from_numpy
,zero_vector
from_numpy
,full
,make_array
,ones
,random
,random_vector
,zeros
Attributes

class
pymor.vectorarrays.list.
NumpyVector
(array)[source]¶ Bases:
pymor.vectorarrays.list.CopyOnWriteVector
Vector stored in a NumPy 1Darray.
Methods
amax
,conj
,dofs
,from_instance
,inner
,norm
,norm2
,to_numpy
axpy
,copy
,scal
sup_norm
Attributes
dim
,imag
,real

class
pymor.vectorarrays.list.
Vector
[source]¶ Bases:
pymor.core.base.BasicObject
Interface for vectors used in conjunction with
ListVectorArray
.This interface must be satisfied by the individual entries of the vector
list
managed byListVectorArray
. All interface methods have a direct counterpart in theVectorArray
interface.Methods
amax
,axpy
,conj
,copy
,dofs
,inner
,norm
,norm2
,scal
,sup_norm
Attributes
imag
,real
mpi module¶
Wrapper classes for building MPI distributed VectorArrays
.
This module contains several wrapper classes which allow to
transform single rank VectorArrays
into MPI distributed
VectorArrays
which can be used on rank 0 like ordinary
VectorArrays
.
The implementations are based on the event loop provided
by pymor.tools.mpi
.

class
pymor.vectorarrays.mpi.
MPIVectorArray
(obj_id, space)[source]¶ Bases:
pymor.vectorarrays.interface.VectorArray
MPI distributed
VectorArray
.Given a local
VectorArray
on each MPI rank, this wrapper class uses the event loop frompymor.tools.mpi
to build a global MPI distributed vector array from these local arrays.Instances of
MPIVectorArray
can be used on rank 0 like any other (nondistributed)VectorArray
.Note, however, that the implementation of the local VectorArrays needs to be MPI aware. For instance,
cls.inner
must perform the needed MPI communication to sum up the local inner products and return the sums on rank 0.Default implementations for all communication requiring interface methods are provided by
MPIVectorArrayAutoComm
(also seeMPIVectorArrayNoComm
).Note that resource cleanup is handled by
object.__del__
. Please be aware of the peculiarities of destructors in Python!The associated
VectorSpace
isMPIVectorSpace
.Methods
amax
,append
,axpy
,copy
,dofs
,inner
,lincomb
,pairwise_inner
,scal
check_ind
,check_ind_unique
,conj
,dot
,empty
,full
,gramian
,l2_norm
,l2_norm2
,len_ind
,len_ind_unique
,norm
,norm2
,normalize_ind
,ones
,pairwise_dot
,random
,sub_index
,sup_norm
,to_numpy
,zeros
Attributes

__getitem__
(ind)[source]¶ Return a
VectorArray
view onto a subset of the vectors in the array.

amax
()[source]¶ The maximum absolute value of the DOFs contained in the array.
Returns
 max_ind
NumPy array
containing for each vector a DOF index at which the maximum is attained. max_val
NumPy array
containing for each vector the maximum absolute value of its DOFs.

append
(other, remove_from_other=False)[source]¶ Append vectors to the array.
Parameters
 other
A
VectorArray
containing the vectors to be appended. remove_from_other
If
True
, the appended vectors are removed fromother
. For listlike implementations this can be used to prevent unnecessary copies of the involved vectors.

axpy
(alpha, x)[source]¶ BLAS AXPY operation.
This method forms the sum
self = alpha*x + self
If the length of
x
is 1, the samex
vector is used for all vectors inself
. Otherwise, the lengths ofself
andx
have to agree. Ifalpha
is a scalar, eachx
vector is multiplied with the same factoralpha
. Otherwise,alpha
has to be a onedimensionalNumPy array
of the same length asself
containing the coefficients for eachx
vector.Parameters
 alpha
The scalar coefficient or onedimensional
NumPy array
of coefficients with which the vectors inx
are multiplied. x
A
VectorArray
containing the xsummands.

copy
(deep=False)[source]¶ Returns a copy of the array.
All
VectorArray
implementations in pyMOR have copyonwrite semantics: if not specified otherwise by settingdeep
toTrue
, the returned copy will hold a handle to the same array data as the original array, and a deep copy of the data will only be performed when one of the arrays is modified.Note that for
NumpyVectorArray
, a deep copy is always performed when only some vectors in the array are copied.Parameters
 deep
Ensure that an actual copy of the array data is made (see above).
Returns
A copy of the
VectorArray
.

dofs
(dof_indices)[source]¶ Extract DOFs of the vectors contained in the array.
Parameters
 dof_indices
List or 1D
NumPy array
of indices of the DOFs that are to be returned.
Returns
A
NumPy array
result
such thatresult[i, j]
is thedof_indices[j]
th DOF of thei
th vector of the array.

inner
(other, product=None)[source]¶ Returns the inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.inner(V)
is equivalent to:
U.dofs(np.arange(U.dim)) @ V.dofs(np.arange(V.dim)).T
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingapply2
, i.e.U.inner(V, product)
is equivalent to:product.apply2(U, V)
which in turn is, by default, implemented as:
U.inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.

lincomb
(coefficients)[source]¶ Returns linear combinations of the vectors contained in the array.
Parameters
 coefficients
A
NumPy array
of dimension 1 or 2 containing the linear coefficients.coefficients.shape[1]
has to agree withlen(self)
.
Returns
A
VectorArray
result
such thatresult[i] = ∑ self[j] * coefficients[i,j]
in case
coefficients
is of dimension 2, otherwiselen(result) == 1
andresult[0] = ∑ self[j] * coefficients[j].

pairwise_inner
(other, product=None)[source]¶ Returns the pairwise inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.pairwise_inner(V)
is equivalent to:
np.sum(U.dofs(np.arange(U.dim)) * V.dofs(np.arange(V.dim)), axis=1)
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingpairwise_apply2
, i.e.U.inner(V, product)
is equivalent to:product.pairwise_apply2(U, V)
which in turn is, by default, implemented as:
U.pairwise_inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.

scal
(alpha)[source]¶ BLAS SCAL operation (inplace scalar multiplication).
This method calculates
self = alpha*self
If
alpha
is a scalar, each vector is multiplied by this scalar. Otherwise,alpha
has to be a onedimensionalNumPy array
of the same length asself
containing the factors for each vector.Parameters
 alpha
The scalar coefficient or onedimensional
NumPy array
of coefficients with which the vectors inself
are multiplied.


class
pymor.vectorarrays.mpi.
MPIVectorArrayAutoComm
(obj_id, space)[source]¶ Bases:
pymor.vectorarrays.mpi.MPIVectorArray
MPI distributed
VectorArray
.This is a subclass of
MPIVectorArray
which provides default implementations for all communication requiring interface methods for the case when the wrapped array is not MPI aware.Note, however, that depending on the model these default implementations might lead to wrong results (for instance in the presence of shared DOFs).
The associated
VectorSpace
isMPIVectorSpaceAutoComm
.Methods
check_ind
,check_ind_unique
,conj
,dot
,empty
,full
,gramian
,l2_norm
,l2_norm2
,len_ind
,len_ind_unique
,norm
,norm2
,normalize_ind
,ones
,pairwise_dot
,random
,sub_index
,sup_norm
,to_numpy
,zeros
Attributes

amax
()[source]¶ The maximum absolute value of the DOFs contained in the array.
Returns
 max_ind
NumPy array
containing for each vector a DOF index at which the maximum is attained. max_val
NumPy array
containing for each vector the maximum absolute value of its DOFs.

dofs
(dof_indices)[source]¶ Extract DOFs of the vectors contained in the array.
Parameters
 dof_indices
List or 1D
NumPy array
of indices of the DOFs that are to be returned.
Returns
A
NumPy array
result
such thatresult[i, j]
is thedof_indices[j]
th DOF of thei
th vector of the array.

inner
(other, product=None)[source]¶ Returns the inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.inner(V)
is equivalent to:
U.dofs(np.arange(U.dim)) @ V.dofs(np.arange(V.dim)).T
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingapply2
, i.e.U.inner(V, product)
is equivalent to:product.apply2(U, V)
which in turn is, by default, implemented as:
U.inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.

pairwise_inner
(other, product=None)[source]¶ Returns the pairwise inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.pairwise_inner(V)
is equivalent to:
np.sum(U.dofs(np.arange(U.dim)) * V.dofs(np.arange(V.dim)), axis=1)
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingpairwise_apply2
, i.e.U.inner(V, product)
is equivalent to:product.pairwise_apply2(U, V)
which in turn is, by default, implemented as:
U.pairwise_inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.


class
pymor.vectorarrays.mpi.
MPIVectorArrayNoComm
(obj_id, space)[source]¶ Bases:
pymor.vectorarrays.mpi.MPIVectorArray
MPI distributed
VectorArray
.This is a subclass of
MPIVectorArray
which overrides all communication requiring interface methods to raiseNotImplementedError
.This is mainly useful as a security measure when wrapping arrays for which simply calling the respective method on the wrapped arrays would lead to wrong results and
MPIVectorArrayAutoComm
cannot be used either (for instance in the presence of shared DOFs).The associated
VectorSpace
isMPIVectorSpaceNoComm
.Methods
check_ind
,check_ind_unique
,conj
,dot
,empty
,full
,gramian
,l2_norm
,l2_norm2
,len_ind
,len_ind_unique
,norm
,norm2
,normalize_ind
,ones
,pairwise_dot
,random
,sub_index
,sup_norm
,to_numpy
,zeros
Attributes

amax
()[source]¶ The maximum absolute value of the DOFs contained in the array.
Returns
 max_ind
NumPy array
containing for each vector a DOF index at which the maximum is attained. max_val
NumPy array
containing for each vector the maximum absolute value of its DOFs.

dofs
(dof_indices)[source]¶ Extract DOFs of the vectors contained in the array.
Parameters
 dof_indices
List or 1D
NumPy array
of indices of the DOFs that are to be returned.
Returns
A
NumPy array
result
such thatresult[i, j]
is thedof_indices[j]
th DOF of thei
th vector of the array.

inner
(other, product=None)[source]¶ Returns the inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.inner(V)
is equivalent to:
U.dofs(np.arange(U.dim)) @ V.dofs(np.arange(V.dim)).T
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingapply2
, i.e.U.inner(V, product)
is equivalent to:product.apply2(U, V)
which in turn is, by default, implemented as:
U.inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.

pairwise_inner
(other, product=None)[source]¶ Returns the pairwise inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.pairwise_inner(V)
is equivalent to:
np.sum(U.dofs(np.arange(U.dim)) * V.dofs(np.arange(V.dim)), axis=1)
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingpairwise_apply2
, i.e.U.inner(V, product)
is equivalent to:product.pairwise_apply2(U, V)
which in turn is, by default, implemented as:
U.pairwise_inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.


class
pymor.vectorarrays.mpi.
MPIVectorSpace
(*args, **kwargs)[source]¶ Bases:
pymor.vectorarrays.interface.VectorSpace
VectorSpace
ofMPIVectorArrays
.Parameters
 local_spaces
tuple
of the differentVectorSpaces
of the localVectorArrays
on the MPI ranks. Alternatively, the length oflocal_spaces
may be 1, in which case the sameVectorSpace
is assumed for all ranks.
Methods
empty
,from_numpy
,full
,ones
,random
Attributes

array_type
¶ alias of
MPIVectorArray

make_array
(obj_id)[source]¶ Create array from ranklocal
VectorArray
instances.Parameters
 obj_id
ObjectId
of the MPI distributed instances ofcls
wrapped by this array.
Returns
The newly created : class:
MPIVectorArray
.

zeros
(count=1, reserve=0)[source]¶ Create a
VectorArray
of null vectorsParameters
 count
The number of vectors.
 reserve
Hint for the backend to which length the array will grow.
Returns
A
VectorArray
containingcount
vectors with each component zero.

class
pymor.vectorarrays.mpi.
MPIVectorSpaceAutoComm
(*args, **kwargs)[source]¶ Bases:
pymor.vectorarrays.mpi.MPIVectorSpace
VectorSpace
forMPIVectorArrayAutoComm
.Methods
empty
,from_numpy
,full
,ones
,random
Attributes

array_type
¶ alias of
MPIVectorArrayAutoComm


class
pymor.vectorarrays.mpi.
MPIVectorSpaceNoComm
(*args, **kwargs)[source]¶ Bases:
pymor.vectorarrays.mpi.MPIVectorSpace
VectorSpace
forMPIVectorArrayNoComm
.Methods
empty
,from_numpy
,full
,ones
,random
Attributes

array_type
¶ alias of
MPIVectorArrayNoComm


class
pymor.vectorarrays.mpi.
RegisteredLocalSpace
[source]¶ Bases:
int
Methods
int
bit_length
,conjugate
,from_bytes
,to_bytes
,__ceil__
,__floor__
,__new__
,__round__
,__sizeof__
,__trunc__
Attributes
int
denominator
,imag
,numerator
,real
numpy module¶

class
pymor.vectorarrays.numpy.
NumpyVectorArray
(array, space)[source]¶ Bases:
pymor.vectorarrays.interface.VectorArray
VectorArray
implementation viaNumPy arrays
.This is the default
VectorArray
type used by allOperators
in pyMOR’s discretization toolkit. Moreover, all reducedOperators
are based onNumpyVectorArray
.This class is just a thin wrapper around the underlying
NumPy array
. Thus, while operations likeaxpy
orinner
will be quite efficient, removing or appending vectors will be costly.Warning
This class is not intended to be instantiated directly. Use the associated
VectorSpace
instead.Methods
amax
,append
,axpy
,conj
,copy
,dofs
,inner
,lincomb
,pairwise_inner
,scal
,sup_norm
,to_numpy
check_ind
,check_ind_unique
,dot
,empty
,full
,gramian
,l2_norm
,l2_norm2
,len_ind
,len_ind_unique
,norm
,norm2
,normalize_ind
,ones
,pairwise_dot
,random
,sub_index
,zeros
Attributes

__getitem__
(ind)[source]¶ Return a
VectorArray
view onto a subset of the vectors in the array.

property
_data
¶ Return NumPy Array view on data for hacking / interactive use.

amax
(*, _ind=None)[source]¶ The maximum absolute value of the DOFs contained in the array.
Returns
 max_ind
NumPy array
containing for each vector a DOF index at which the maximum is attained. max_val
NumPy array
containing for each vector the maximum absolute value of its DOFs.

append
(other, remove_from_other=False)[source]¶ Append vectors to the array.
Parameters
 other
A
VectorArray
containing the vectors to be appended. remove_from_other
If
True
, the appended vectors are removed fromother
. For listlike implementations this can be used to prevent unnecessary copies of the involved vectors.

axpy
(alpha, x, *, _ind=None)[source]¶ BLAS AXPY operation.
This method forms the sum
self = alpha*x + self
If the length of
x
is 1, the samex
vector is used for all vectors inself
. Otherwise, the lengths ofself
andx
have to agree. Ifalpha
is a scalar, eachx
vector is multiplied with the same factoralpha
. Otherwise,alpha
has to be a onedimensionalNumPy array
of the same length asself
containing the coefficients for eachx
vector.Parameters
 alpha
The scalar coefficient or onedimensional
NumPy array
of coefficients with which the vectors inx
are multiplied. x
A
VectorArray
containing the xsummands.

copy
(deep=False, *, _ind=None)[source]¶ Returns a copy of the array.
All
VectorArray
implementations in pyMOR have copyonwrite semantics: if not specified otherwise by settingdeep
toTrue
, the returned copy will hold a handle to the same array data as the original array, and a deep copy of the data will only be performed when one of the arrays is modified.Note that for
NumpyVectorArray
, a deep copy is always performed when only some vectors in the array are copied.Parameters
 deep
Ensure that an actual copy of the array data is made (see above).
Returns
A copy of the
VectorArray
.

dofs
(dof_indices, *, _ind=None)[source]¶ Extract DOFs of the vectors contained in the array.
Parameters
 dof_indices
List or 1D
NumPy array
of indices of the DOFs that are to be returned.
Returns
A
NumPy array
result
such thatresult[i, j]
is thedof_indices[j]
th DOF of thei
th vector of the array.

property
imag
¶ Imaginary part.

inner
(other, product=None, *, _ind=None)[source]¶ Returns the inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.inner(V)
is equivalent to:
U.dofs(np.arange(U.dim)) @ V.dofs(np.arange(V.dim)).T
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingapply2
, i.e.U.inner(V, product)
is equivalent to:product.apply2(U, V)
which in turn is, by default, implemented as:
U.inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.

lincomb
(coefficients, *, _ind=None)[source]¶ Returns linear combinations of the vectors contained in the array.
Parameters
 coefficients
A
NumPy array
of dimension 1 or 2 containing the linear coefficients.coefficients.shape[1]
has to agree withlen(self)
.
Returns
A
VectorArray
result
such thatresult[i] = ∑ self[j] * coefficients[i,j]
in case
coefficients
is of dimension 2, otherwiselen(result) == 1
andresult[0] = ∑ self[j] * coefficients[j].

pairwise_inner
(other, product=None, *, _ind=None)[source]¶ Returns the pairwise inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.pairwise_inner(V)
is equivalent to:
np.sum(U.dofs(np.arange(U.dim)) * V.dofs(np.arange(V.dim)), axis=1)
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingpairwise_apply2
, i.e.U.inner(V, product)
is equivalent to:product.pairwise_apply2(U, V)
which in turn is, by default, implemented as:
U.pairwise_inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.

property
real
¶ Real part.

scal
(alpha, *, _ind=None)[source]¶ BLAS SCAL operation (inplace scalar multiplication).
This method calculates
self = alpha*self
If
alpha
is a scalar, each vector is multiplied by this scalar. Otherwise,alpha
has to be a onedimensionalNumPy array
of the same length asself
containing the factors for each vector.Parameters
 alpha
The scalar coefficient or onedimensional
NumPy array
of coefficients with which the vectors inself
are multiplied.

sup_norm
(*, _ind=None)[source]¶ The linfinitynorms of the vectors contained in the array.
Returns
A
NumPy array
result
such thatresult[i]
contains the norm ofself[i]
.

to_numpy
(ensure_copy=False)[source]¶ Return (len(self), self.dim) NumPy Array with the data stored in the array.
Parameters
 ensure_copy
If
False
, modifying the returnedNumPy array
might alter the originalVectorArray
. IfTrue
always a copy of the array data is made.


class
pymor.vectorarrays.numpy.
NumpyVectorArrayView
(array, ind)[source]¶ Bases:
pymor.vectorarrays.numpy.NumpyVectorArray
Methods
amax
,append
,axpy
,copy
,dofs
,inner
,lincomb
,pairwise_inner
,scal
,sup_norm
,to_numpy
check_ind
,check_ind_unique
,dot
,empty
,full
,gramian
,l2_norm
,l2_norm2
,len_ind
,len_ind_unique
,norm
,norm2
,normalize_ind
,ones
,pairwise_dot
,random
,sub_index
,zeros
Attributes

__getitem__
(ind)[source]¶ Return a
VectorArray
view onto a subset of the vectors in the array.

amax
()[source]¶ The maximum absolute value of the DOFs contained in the array.
Returns
 max_ind
NumPy array
containing for each vector a DOF index at which the maximum is attained. max_val
NumPy array
containing for each vector the maximum absolute value of its DOFs.

append
(other, remove_from_other=False)[source]¶ Append vectors to the array.
Parameters
 other
A
VectorArray
containing the vectors to be appended. remove_from_other
If
True
, the appended vectors are removed fromother
. For listlike implementations this can be used to prevent unnecessary copies of the involved vectors.

axpy
(alpha, x)[source]¶ BLAS AXPY operation.
This method forms the sum
self = alpha*x + self
If the length of
x
is 1, the samex
vector is used for all vectors inself
. Otherwise, the lengths ofself
andx
have to agree. Ifalpha
is a scalar, eachx
vector is multiplied with the same factoralpha
. Otherwise,alpha
has to be a onedimensionalNumPy array
of the same length asself
containing the coefficients for eachx
vector.Parameters
 alpha
The scalar coefficient or onedimensional
NumPy array
of coefficients with which the vectors inx
are multiplied. x
A
VectorArray
containing the xsummands.

copy
(deep=False)[source]¶ Returns a copy of the array.
All
VectorArray
implementations in pyMOR have copyonwrite semantics: if not specified otherwise by settingdeep
toTrue
, the returned copy will hold a handle to the same array data as the original array, and a deep copy of the data will only be performed when one of the arrays is modified.Note that for
NumpyVectorArray
, a deep copy is always performed when only some vectors in the array are copied.Parameters
 deep
Ensure that an actual copy of the array data is made (see above).
Returns
A copy of the
VectorArray
.

dofs
(dof_indices)[source]¶ Extract DOFs of the vectors contained in the array.
Parameters
 dof_indices
List or 1D
NumPy array
of indices of the DOFs that are to be returned.
Returns
A
NumPy array
result
such thatresult[i, j]
is thedof_indices[j]
th DOF of thei
th vector of the array.

inner
(other, product=None)[source]¶ Returns the inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.inner(V)
is equivalent to:
U.dofs(np.arange(U.dim)) @ V.dofs(np.arange(V.dim)).T
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingapply2
, i.e.U.inner(V, product)
is equivalent to:product.apply2(U, V)
which in turn is, by default, implemented as:
U.inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.

lincomb
(coefficients)[source]¶ Returns linear combinations of the vectors contained in the array.
Parameters
 coefficients
A
NumPy array
of dimension 1 or 2 containing the linear coefficients.coefficients.shape[1]
has to agree withlen(self)
.
Returns
A
VectorArray
result
such thatresult[i] = ∑ self[j] * coefficients[i,j]
in case
coefficients
is of dimension 2, otherwiselen(result) == 1
andresult[0] = ∑ self[j] * coefficients[j].

pairwise_inner
(other, product=None)[source]¶ Returns the pairwise inner products between
VectorArray
elements.If
product
isNone
, the Euclidean inner product between thedofs
ofself
andother
are returned, i.e.U.pairwise_inner(V)
is equivalent to:
np.sum(U.dofs(np.arange(U.dim)) * V.dofs(np.arange(V.dim)), axis=1)
(Note, that
dofs
is only intended to be called for a small number of DOF indices.)If a
product
Operator
is specified, thisOperator
is used to compute the inner products usingpairwise_apply2
, i.e.U.inner(V, product)
is equivalent to:product.pairwise_apply2(U, V)
which in turn is, by default, implemented as:
U.pairwise_inner(product.apply(V))
In the case of complex numbers, this is antilinear in the first argument, i.e. in ‘self’. Complex conjugation is done in the first argument because most numerical software in the community handles it this way: Numpy, DUNE, FEniCS, Eigen, Matlab and BLAS do complex conjugation in the first argument, only PetSc and deal.ii do complex conjugation in the second argument.
Parameters
 other
A
VectorArray
containing the second factors. product
If not
None
anOperator
representing the inner product bilinear form.

scal
(alpha)[source]¶ BLAS SCAL operation (inplace scalar multiplication).
This method calculates
self = alpha*self
If
alpha
is a scalar, each vector is multiplied by this scalar. Otherwise,alpha
has to be a onedimensionalNumPy array
of the same length asself
containing the factors for each vector.Parameters
 alpha
The scalar coefficient or onedimensional
NumPy array
of coefficients with which the vectors inself
are multiplied.

sup_norm
()[source]¶ The linfinitynorms of the vectors contained in the array.
Returns
A
NumPy array
result
such thatresult[i]
contains the norm ofself[i]
.

to_numpy
(ensure_copy=False)[source]¶ Return (len(self), self.dim) NumPy Array with the data stored in the array.
Parameters
 ensure_copy
If
False
, modifying the returnedNumPy array
might alter the originalVectorArray
. IfTrue
always a copy of the array data is made.


class
pymor.vectorarrays.numpy.
NumpyVectorSpace
(*args, **kwargs)[source]¶ Bases:
pymor.vectorarrays.interface.VectorSpace
VectorSpace
ofNumpyVectorArrays
.Parameters
 dim
The dimension of the vectors contained in the space.
 id
See
id
.
Methods
from_file
,from_numpy
,full
,make_array
,random
,zeros
Attributes

full
(value, count=1, reserve=0)[source]¶ Create a
VectorArray
of vectors with all DOFs set to the same value.Parameters
 value
The value each DOF should be set to.
 count
The number of vectors.
 reserve
Hint for the backend to which length the array will grow.
Returns
A
VectorArray
containingcount
vectors with each DOF set tovalue
.

property
is_scalar
¶ bool(x) > bool
Returns True when the argument x is true, False otherwise. The builtins True and False are the only two instances of the class bool. The class bool is a subclass of the class int, and cannot be subclassed.

random
(count=1, distribution='uniform', random_state=None, seed=None, reserve=0, **kwargs)[source]¶ Create a
VectorArray
of vectors with random entries.Supported random distributions:
'uniform': Uniform distribution in halfopen interval [`low`, `high`). 'normal': Normal (Gaussian) distribution with mean `loc` and standard deviation `scale`.
Note that not all random distributions are necessarily implemented by all
VectorSpace
implementations.Parameters
 count
The number of vectors.
 distribution
Random distribution to use (
'uniform'
,'normal'
). low
Lower bound for
'uniform'
distribution (defaults to0
). high
Upper bound for
'uniform'
distribution (defaults to1
). loc
Mean for
'normal'
distribution (defaults to0
). scale
Standard deviation for
'normal'
distribution (defaults to1
). random_state
RandomState
to use for sampling. IfNone
, a new random state is generated usingseed
as random seed, or thedefault
random state is used. seed
If not
None
, a new random state with this seed is used. reserve
Hint for the backend to which length the array will grow.

zeros
(count=1, reserve=0)[source]¶ Create a
VectorArray
of null vectorsParameters
 count
The number of vectors.
 reserve
Hint for the backend to which length the array will grow.
Returns
A
VectorArray
containingcount
vectors with each component zero.