Unverified Commit 349eb060 authored by René Fritze's avatar René Fritze Committed by GitHub

add topics for 2020.2 release notes (#1201)

Adds the release notes for the 2020.2.0 release
parents 417013bc f5ef7d71
Pipeline #70215 passed with stages
in 32 minutes and 57 seconds
......@@ -18,7 +18,7 @@ provided for getting started quickly.
pyMOR 0.3 (March 2, 2015)
- Introduction of the vector space concept for even simpler
integration with external solvers.
- Addition of a generic Newton algorithm.
- Support for Jacobian evaluation of empirically interpolated operators.
- Greatly improved performance of the EI-Greedy algorithm. Addition of
the DEIM algorithm.
- A new algorithm for residual operator projection and a new,
numerically stable a posteriori error estimator for stationary coercive
problems based on this algorithm. (cf. A. Buhr, C. Engwer, M. Ohlberger,
S. Rave, 'A numerically stable a posteriori error estimator for reduced
basis approximations of elliptic equations', proceedings of WCCM 2014,
Barcelona, 2014.)
- A new, easy to use mechanism for setting and accessing default values.
- Serialization via the pickle module is now possible for each class in
pyMOR. (See the new 'analyze_pickle' demo.)
- Addition of generic iterative linear solvers which can be used in
conjunction with any operator satisfying pyMOR's operator interface.
Support for least squares solvers and PyAMG (http://www.pyamg.org/).
- An improved SQLite-based cache backend.
- Improvements to the built-in discretizations: support for bilinear
finite elements and addition of a finite volume diffusion operator.
- Test coverage has been raised from 46% to 75%.
Over 500 single commits have entered this release. A full list of
all changes can be obtained under the following address:
pyMOR 0.5 (January 17, 2019)
After more than two years of development, we are proud to announce the release
of pyMOR 0.5! Highlights of this release are support for Python 3, bindings for
the NGSolve finite element library, new linear algebra algorithms, various
|VectorArray| usability improvements, as well as a redesign of pyMOR's
projection algorithms based on |RuleTables|.
Especially we would like to highlight the addition of various system-theoretic
reduction methods such as Balanced Truncation or IRKA. All algorithms are
implemented in terms of pyMOR's |Operator| and |VectorArray| interfaces,
allowing their application to any model implemented using one of the PDE solver
supported by pyMOR. In particular, no import of the system matrices is
Over 1,500 single commits have entered this release. For a full list of changes
see `here <https://github.com/pymor/pymor/compare/0.4.x...0.5.x>`__.
pyMOR 0.5 contains contributions by Linus Balicki, Julia Brunken and Christoph
Lehrenfeld. See `here <https://github.com/pymor/pymor/blob/master/AUTHORS.md>`__
for more details.
Release highlights
Python 3 support
pyMOR is now compatible with Python 3.5 or greater. Since the use of Python 3 is
now standard in the scientific computing community and security updates for
Python 2 will stop in less than a year (https://pythonclock.org), we decided to
no longer support Python 2 and make pyMOR 0.5 a Python 3-only release. Switching
to Python 3 also allows us to leverage newer language features such as the `@`
binary operator for concatenation of |Operators|, keyword-only arguments or
improved support for asynchronous programming.
System-theoretic MOR methods
With 386 commits, `[#464] <https://github.com/pymor/pymor/pull/464>`_ added
systems-theoretic methods to pyMOR. Module :mod:`pymor.discretizations.iosys`
contains new discretization classes for input-output systems, e.g. `LTISystem`,
`SecondOrderSystem` and |TransferFunction|. At present, methods related to these
classes mainly focus on continuous-time, non-parametric systems.
Since matrix equation solvers are important tools in many system-theoretic
methods, support for Lyapunov, Riccati and Sylvester equations has been added in
:mod:`pymor.algorithms.lyapunov`, :mod:`pymor.algorithms.riccati` and
:mod:`pymor.algorithms.sylvester`. A generic low-rank ADI (Alternating Direction
Implicit) solver for Lyapunov equations is implemented in
:mod:`pymor.algorithms.lradi`. Furthermore, bindings to low-rank and dense
solvers for Lyapunov and Riccati equations from |SciPy|,
`Slycot <https://github.com/python-control/Slycot>`_ and
`Py-M.E.S.S. <https://www.mpi-magdeburg.mpg.de/projects/mess>`_ are provided in
:mod:`pymor.bindings.scipy`, :mod:`pymor.bindings.slycot` and
:mod:`pymor.bindings.pymess`. A generic Schur decomposition-based solver for
sparse-dense Sylvester equations is implemented in
Balancing Truncation (BT) and Iterative Rational Krylov Algorithm (IRKA) are
implemented in :class:`~pymor.reductors.bt.BTReductor` and
:class:`~pymor.reductors.h2.IRKAReductor`. LQG and Bounded Real variants of BT
are also available (:class:`~pymor.reductors.bt.LQGBTReductor`,
:class:`~pymor.reductors.bt.BRBTReductor`). Bitangential Hermite interpolation
(used in IRKA) is implemented in
:class:`~pymor.reductors.interpolation.LTI_BHIReductor`. Two-Sided Iteration
Algorithm (TSIA), a method related to IRKA, is implemented in
Several structure-preserving MOR methods for second-order systems have been
implemented. Balancing-based MOR methods are implemented in
:mod:`pymor.reductors.sobt`, bitangential Hermite interpolation in
:class:`~pymor.reductors.interpolation.SO_BHIReductor` and Second-Order Reduced
IRKA (SOR-IRKA) in :class:`~pymor.reductors.sor_irka.SOR_IRKAReductor`.
For more general transfer functions, MOR methods which return `LTISystems` are
also available. Bitangential Hermite interpolation is implemented in
:class:`~pymor.reductors.interpolation.TFInterpReductor` and Transfer Function
IRKA (TF-IRKA) in :class:`~pymor.reductors.h2.TF_IRKAReductor`.
Usage examples can be found in the `heat` and `string_equation` demo scripts.
NGSolve support
We now ship bindings for the `NGSolve <https://ngsolve.org>`_ finite element
library. Wrapper classes for |VectorArrays| and matrix-based |Operators| can be
found in the :mod:`pymor.bindings.ngsolve` module. A usage example can be found
in the `thermalblock_simple` demo script.
New linear algebra algorithms
pyMOR now includes an implementation of the
`HAPOD algorithm <https://doi.org/10.1137/16M1085413>`_ for fast distributed
or incremental computation of the Proper Orthogonal Decomposition
(:mod:`pymor.algorithms.hapod`). The code allows for arbitrary sub-POD trees,
on-the-fly snapshot generation and shared memory parallelization via
:mod:`concurrent.futures`. A basic usage example can be found in the `hapod`
demo script.
In addition, the Gram-Schmidt biorthogonalization algorithm has been included in
VectorArray improvements
|VectorArrays| in pyMOR have undergone several usability improvements:
- The somewhat dubious concept of a `subtype` has been superseded by the concept
of |VectorSpaces| which act as factories for |VectorArrays|. In particular,
instead of a `subtype`, |VectorSpaces| can now hold meaningful attributes
(e.g. the dimension) which are required to construct |VectorArrays| contained
in the space. The
:attr:`~pymor.vectorarrays.interfaces.VectorSpaceInterface.id` attribute
allows to differentiate between technically identical but mathematically
different spaces `[#323] <https://github.com/pymor/pymor/pull/323>`_.
- |VectorArrays| can now be indexed to select a subset of vectors to operate on.
In contrast to advanced indexing in |NumPy|, indexing a |VectorArray| will
always return a view onto the original array data
`[#299] <https://github.com/pymor/pymor/pull/299>`_.
- New methods with clear semantics have been introduced for the conversion of
|VectorArrays| to
(:meth:`~pymor.vectorarrays.interfaces.VectorArrayInterface.to_numpy`) and
from (:meth:`~pymor.vectorarrays.interfaces.VectorSpaceInterface.from_numpy`)
|NumPy arrays| `[#446] <https://github.com/pymor/pymor/pull/446>`_.
- Inner products between |VectorArrays| w.r.t. to a given inner product
|Operator| or their norm w.r.t. such an operator can now easily be computed by
passing the |Operator| as the optional `product` argument to the new
:meth:`~pymor.vectorarrays.interfaces.VectorArrayInterface.inner` and
:meth:`~pymor.vectorarrays.interfaces.VectorArrayInterface.norm` methods
`[#407] <https://github.com/pymor/pymor/pull/407>`_.
- The `components` method of |VectorArrays| has been renamed to the more
intuitive name
`[#414] <https://github.com/pymor/pymor/pull/414>`_.
- The :meth:`~pymor.vectorarrays.interfaces.VectorArrayInterface.l2_norm2` and
:meth:`~pymor.vectorarrays.interfaces.VectorArrayInterface.norm2` have been
introduced to compute the squared vector norms
`[#237] <https://github.com/pymor/pymor/pull/237>`_.
RuleTable based algorithms
In pyMOR 0.5, projection algorithms are implemented via recursively applied
tables of transformation rules. This replaces the previous inheritance-based
approach. In particular, the `projected` method to perform a (Petrov-)Galerkin
projection of an arbitrary |Operator| has been removed and replaced by a free
|project| function. Rule-based algorithms are implemented by deriving from the
|RuleTable| base class `[#367] <https://github.com/pymor/pymor/pull/367>`_,
`[#408] <https://github.com/pymor/pymor/pull/408>`_.
This approach has several advantages:
- Rules can match based on the class of the object, but also on more general
conditions, e.g. the name of the |Operator| or being linear and
- The entire mathematical algorithm can be specified in a single file even when
the definition of the possible classes the algorithm can be applied to is
scattered over various files.
- The precedence of rules is directly apparent from the definition of the
- Generic rules (e.g. the projection of a linear non-|parametric| |Operator| by
simply applying the basis) can be easily scheduled to take precedence over
more specific rules.
- Users can implement or modify |RuleTables| without modification of the classes
shipped with pyMOR.
Additional new features
- Reduction algorithms are now implemented using mutable reductor objects, e.g.
:class:`~pymor.reductors.basic.GenericRBReductor`, which store and
:meth:`extend <pymor.reductors.basic.GenericRBReductor.extend_basis>` the
reduced bases onto which the model is projected. The only return value of the
reductor's :meth:`~pymor.reductors.basic.GenericRBReductor.reduce` method is
now the reduced discretization. Instead of a separate reconstructor, the
reductor's :meth:`~pymor.reductors.basic.GenericRBReductor.reconstruct` method
can be used to reconstruct a high-dimensional state-space representation.
Additional reduction data (e.g. used to speed up repeated reductions in greedy
algorithms) is now managed by the reductor
`[#375] <https://github.com/pymor/pymor/pull/375>`_.
- Linear combinations and concatenations of |Operators| can now easily be formed
using arithmetic operators `[#421] <https://github.com/pymor/pymor/pull/421>`_.
- The handling of complex numbers in pyMOR is now more consistent. See
`[#458] <https://github.com/pymor/pymor/pull/459>`_,
`[#362] <https://github.com/pymor/pymor/pull/362>`_,
`[#447] <https://github.com/pymor/pymor/pull/447>`_
for details. As a consequence of these changes, the `rhs` |Operator| in
`StationaryDiscretization` is now a vector-like |Operator| instead of a functional.
- The analytical problems and discretizers of pyMOR's discretization toolbox
have been reorganized and improved. All problems are now implemented as
instances of |StationaryProblem| or |InstationaryProblem|, which allows an
easy exchange of data |Functions| of a predefined problem with user-defined
|Functions|. Affine decomposition of |Functions| is now represented by
specifying a :class:`~pymor.functions.basic.LincombFunction` as the respective
data function
`[#312] <https://github.com/pymor/pymor/pull/312>`_,
`[#316] <https://github.com/pymor/pymor/pull/316>`_,
`[#318] <https://github.com/pymor/pymor/pull/318>`_,
`[#337] <https://github.com/pymor/pymor/pull/337>`_.
- The :mod:`pymor.core.config` module allows simple run-time checking of the
availability of optional dependencies and their versions
`[#339] <https://github.com/pymor/pymor/pull/339>`_.
- Packaging improvements
A compiler toolchain is no longer necessary to install pyMOR as we are now
distributing binary wheels for releases through the Python Package Index
(PyPI). Using the `extras_require` mechanism the user can select to install
either a minimal set::
pip install pymor
or almost all, including optional, dependencies::
pip install pymor[full]
A docker image containing all of the discretization packages pyMOR has
bindings to is available for demonstration and development purposes::
docker run -it pymor/demo:0.5 pymor-demo -h
docker run -it pymor/demo:0.5 pymor-demo thermalblock --fenics 2 2 5 5
Backward incompatible changes
- `dim_outer` has been removed from the grid interface `[#277]
- All wrapper code for interfacing with external PDE libraries or equation
solvers has been moved to the :mod:`pymor.bindings` package. For instance,
`FenicsMatrixOperator` can now be found in the :mod:`pymor.bindings.fenics`
module. `[#353] <https://github.com/pymor/pymor/pull/353>`_
- The `source` and `range` arguments of the constructor of
:class:`~pymor.operators.constructions.ZeroOperator` have
been swapped to comply with related function signatures
`[#415] <https://github.com/pymor/pymor/pull/415>`_.
- The identifiers `discretization`, `rb_discretization`, `ei_discretization`
have been replaced by `d`, `rd`, `ei_d` throughout pyMOR
`[#416] <https://github.com/pymor/pymor/pull/416>`_.
- The `_matrix` attribute of |NumpyMatrixOperator| has been renamed to `matrix`
`[#436] <https://github.com/pymor/pymor/pull/436>`_. If `matrix` holds a
|NumPy array| this array is automatically made read-only to prevent accidental
modification of the |Operator| `[#462] <https://github.com/pymor/pymor/pull/462>`_.
- The `BoundaryType` class has been removed in favor of simple strings `[#305]
- The complicated and unused mapping of local parameter component names to
global names has been removed `[#306] <https://github.com/pymor/pymor/pull/306>`_.
Further notable improvements
- `[#176] Support different colormaps in GLPatchWidget <https://github.com/pymor/pymor/pull/176>`_.
- `[#238] From Operator to NumPy operator <https://github.com/pymor/pymor/pull/238>`_.
- `[#308] Add NumpyGenericOperator.apply_adjoint <https://github.com/pymor/pymor/pull/308>`_.
- `[#313] Add finiteness checks to linear solvers <https://github.com/pymor/pymor/pull/313>`_.
- `[#314] [ExpressionFunction] add components of mu to locals <https://github.com/pymor/pymor/pull/314>`_.
- `[#315] [functions] some improvements to ExpressionFunction/GenericFunction <https://github.com/pymor/pymor/pull/315>`_.
- `[#338] Do not print version string on import <https://github.com/pymor/pymor/pull/338>`_.
- `[#346] Implement more arithmetic operations on VectorArrays and Operators <https://github.com/pymor/pymor/pull/346>`_.
- `[#348] add InverseOperator and InverseTransposeOperator <https://github.com/pymor/pymor/pull/348>`_.
- `[#359] [grids] bugfix for boundary handling in subgrid <https://github.com/pymor/pymor/pull/359>`_.
- `[#365] [operators] add ProxyOperator <https://github.com/pymor/pymor/pull/365>`_.
- `[#366] [operators] add LinearOperator and AffineOperator <https://github.com/pymor/pymor/pull/366>`_.
- `[#368] Add support for PyQt4 and PyQt5 by using Qt.py shim <https://github.com/pymor/pymor/pull/368>`_.
- `[#369] Add basic support for visualization in juypter notebooks <https://github.com/pymor/pymor/pull/369>`_.
- `[#370] Let BitmapFunction accept non-grayscale images <https://github.com/pymor/pymor/pull/370>`_.
- `[#382] Support mpi4py > 2.0 <https://github.com/pymor/pymor/pull/382>`_.
- `[#401] [analyticalproblems] add text_problem <https://github.com/pymor/pymor/pull/401>`_.
- `[#410] add relative_error and project_array functions <https://github.com/pymor/pymor/pull/410>`_.
- `[#422] [Concatenation] allow more than two operators in a Concatenation <https://github.com/pymor/pymor/pull/422>`_.
- `[#425] [ParameterType] base implementation on OrderedDict <https://github.com/pymor/pymor/pull/425>`_.
- `[#431] [operators.cg] fix first order integration <https://github.com/pymor/pymor/pull/431>`_.
- `[#437] [LincombOperator] implement 'apply_inverse' <https://github.com/pymor/pymor/pull/437>`_.
- `[#438] Fix VectorArrayOperator, generalize as_range/source_array <https://github.com/pymor/pymor/pull/438>`_.
- `[#441] fix #439 (assemble_lincomb "operators" parameter sometimes list, sometimes tuple) <https://github.com/pymor/pymor/pull/441>`_.
- `[#452] Several improvements to pymor.algorithms.ei.deim <https://github.com/pymor/pymor/pull/452>`_.
- `[#453] Extend test_assemble <https://github.com/pymor/pymor/pull/453>`_.
- `[#480| [operators] Improve subtraction of LincombOperators <https://github.com/pymor/pymor/pull/480>`_.
- `[#481] [project] ensure solver_options are removed from projected operators <https://github.com/pymor/pymor/pull/481>`_.
- `[#484] [docs] move all references to bibliography.rst <https://github.com/pymor/pymor/pull/484>`_.
- `[#488] [operators.block] add BlockRowOperator, BlockColumnOperator <https://github.com/pymor/pymor/pull/488>`_.
- `[#489] Output functionals in CG discretizations <https://github.com/pymor/pymor/pull/489>`_.
- `[#497] Support automatic conversion of InstationaryDiscretization to LTISystem <https://github.com/pymor/pymor/pull/497>`_.
pyMOR 2019.2 (December 16, 2019)
We are proud to announce the release of pyMOR 2019.2! For this release we have
worked hard to make implementing new models and reduction algorithms with pyMOR
even easier. Further highlights of this release are an extended VectorArray
interface with generic support for complex numbers, vastly extended and
improved system-theoretic MOR methods, as well as builtin support for model
outputs and parameter sensitivities.
Over 700 single commits have entered this release. For a full list of changes
see `here <https://github.com/pymor/pymor/compare/0.5.x...2019.2.x>`__.
pyMOR 2019.2 contains contributions by Linus Balicki, Dennis Eickhorn and Tim
Keil. See `here <https://github.com/pymor/pymor/blob/master/AUTHORS.md>`__ for
more details.
Release highlights
Implement new models and reductors more easily
As many users have been struggling with the notion of `Discretization` in pyMOR
and to account for the fact that not every full-order model needs to be a discretized
PDE model, we have decided to rename `DiscretizationInterface` to
:class:`~pymor.models.interfaces.ModelInterface` and all deriving classes accordingly
`[#568] <https://github.com/pymor/pymor/pull/568>`_. Consequently, the variable names
`m`, `rom`, `fom` will now be found throughout pyMOR's code to refer to an arbitrary
|Model|, a reduced-order |Model| or a full-order |Model|.
Moreover, following the `Zen of Python's <https://www.python.org/dev/peps/pep-0020/>`_
'Explicit is better than implicit' and 'Simple is better than complex', we have
completely revamped the implementation of |Models| and :mod:`~pymor.reductors`
to facilitate the implementation of new model types and reduction methods
`[#592] <https://github.com/pymor/pymor/pull/592>`_. In particular, the complicated
and error-prone approach of trying to automatically correctly project the |Operators|
of any given |Model| in `GenericRBReductor` and `GenericPGReductor` has been replaced
by simple |Model|-adapted reductors which explicitly state with which bases each
|Operator| shall be projected. As a consequence, we could remove the `operators` dict
and the notion of `special_operators` in :class:`~pymor.models.basic.ModelBase`,
vastly simplifying its implementation and the definition of new |Model| classes.
Extended VectorArray interface with generic complex number support
The :class:`~pymor.vectorarrays.interfaces.VectorArrayInterface` has been extended to
allow the creation of non-zero vectors using the
:meth:`~pymor.vectorarrays.interfaces.VectorArrayInterface.ones` and
:meth:`~pymor.vectorarrays.interfaces.VectorArrayInterface.full` methods
`[#612] <https://github.com/pymor/pymor/pull/612>`_. Vectors with random values can
be created using the :meth:`~pymor.vectorarrays.interfaces.VectorArrayInterface.random`
method `[#618] <https://github.com/pymor/pymor/pull/618>`_. All |VectorArray|
implementations shipped with pyMOR support these new interface methods.
As an important step to improve the support for system-theoretic MOR methods with
external PDE solvers, we have implemented facilities to provide generic support
for complex-valued |VectorArrays| even for PDE solvers that do not support complex
vectors natively `[#755] <https://github.com/pymor/pymor/pull/755>`_.
Improved and extended support for system-theoretic MOR methods
To increase compatibility between input-output models in
:mod:`~pymor.models.iosys` and the |InstationaryModel|, support for models with
parametric operators has been added
`[#626] <https://github.com/pymor/pymor/pull/626>`_, which also enables
implementation of parametric MOR methods for such models.
Furthermore, the `state_space` attribute was removed in favor of
`solution_space` `[#648] <https://github.com/pymor/pymor/pull/648>`_ to make
more explicit the result of the
:meth:`~pymor.models.interfaces.ModelInterface.solve` method.
Further improvements in naming has been renaming attributes `n`, `m`, and `p` to
`order`, `input_dim`, and `output_dim`
`[#578] <https://github.com/pymor/pymor/pull/578>`_ and the `bode` method to
`[#729] <https://github.com/pymor/pymor/pull/729>`_.
Reductors in :mod:`~pymor.reductors.bt` and :mod:`~pymor.reductors.h2` received
numerous improvements (`[#656] <https://github.com/pymor/pymor/pull/656>`_,
`[#661] <https://github.com/pymor/pymor/pull/661>`_,
`[#807] <https://github.com/pymor/pymor/pull/807>`_) and variants of one-sided
IRKA have been added `[#579] <https://github.com/pymor/pymor/pull/579>`_.
As for Lyapunov equations, a low-rank solver for Riccati equations has been
added `[#736] <https://github.com/pymor/pymor/pull/736>`_.
Model outputs and parameter sensitivities
The notion of a |Model|'s output has been formally added to the
:class:`~pymor.models.interfaces.ModelInterface` `[#750] <https://github.com/pymor/pymor/pull/750>`_:
The output of a |Model| is defined to be a |VectorArray| of the model's
:attr:`~pymor.models.interfaces.ModelInterface.output_space` |VectorSpace| and
can be computed using the new :meth:`~pymor.models.interfaces.ModelInterface.output` method.
Alternatively, :meth:`~pymor.models.interfaces.ModelInterface.solve` method can
now be called with `return_output=True` to return the output alongside the state space
To compute parameter sensitivities, we have added `d_mu` methods to
:meth:`OperatorInterface <pymor.operators.interfaces.OperatorInterface.d_mu>` and
:meth:`ParameterFunctionalInterface <pymor.parameters.interfaces.ParameterFunctionalInterface.d_mu>`
which return the partial derivative with respect to a given parameter component
`[#748] <https://github.com/pymor/pymor/pull/748>`_.
Additional new features
Extended FEniCS bindings
FEniCS support has been improved by adding support for nonlinear |Operators| including
an implementation of :meth:`~pymor.operators.interfaces.OperatorInterface.restricted`
to enable fast local evaluation of the operator for efficient
:class:`empirical interpolation <pymor.operators.ei.EmpiricalInterpolatedOperator>`
`[#819] <https://github.com/pymor/pymor/pull/819>`_. Moreover the parallel implementations
of :meth:`~pymor.vectorarrays.interfaces.VectorArrayInterface.amax` and
:meth:`~pymor.vectorarrays.interfaces.VectorArrayInterface.dofs` have been fixed
`[#616] <https://github.com/pymor/pymor/pull/616>`_ and
:attr:`~pymor.operators.interfaces.OperatorInterface.solver_options` are now correctly
handled in :meth:`~pymor.operators.interfaces.OperatorInterface._assemble_lincomb`
`[#812] <https://github.com/pymor/pymor/pull/812>`_.
Improved greedy algorithms
pyMOR's greedy algorithms have been refactored into :func:`~pymor.algorithms.greedy.weak_greedy`
and :func:`~pymor.algorithms.adaptivegreedy.adaptive_weak_greedy` functions that
use a common :class:`~pymor.algorithms.greedy.WeakGreedySurrogate` to estimate
the approximation error and extend the greedy bases. This allows these functions to be
used more flexible, e.g. for goal-oriented basis generation, by implementing a new
:class:`~pymor.algorithms.greedy.WeakGreedySurrogate` `[#757] <https://github.com/pymor/pymor/pull/757>`_.
Numerical linear algebra algorithms
By specifying `return_R=True`, the :func:`~pymor.algorithms.gram_schmidt.gram_schmidt`
algorithm can now also be used to compute a QR decomposition of a given |VectorArray|
`[#577] <https://github.com/pymor/pymor/pull/577>`_. Moreover,
:func:`~pymor.algorithms.gram_schmidt.gram_schmidt` can be used as a more accurate
(but often more expensive) alternative for computing the :func:`~pymor.algorithms.pod.pod` of
a |Vectorarray|. Both, the older method-of-snapshots approach as well as the QR decomposition
are now available for computing a truncated SVD of a |VectorArray| via the newly added
:mod:`~pymor.algorithms.svd_va` module `[#718] <https://github.com/pymor/pymor/pull/718>`_.
Basic randomized algorithms for approximating the image of a linear |Operator| are
implemented in the :mod:`~pymor.algorithms.randrangefinder` module
`[#665] <https://github.com/pymor/pymor/pull/665>`_.
Support for low-rank operators
Low-rank |Operators| and as well as sums of arbitrary |Operators| with a low-rank
|Operator| can now be represented by :class:`~pymor.operators.constructions.LowRankOperator`
and :class:`~pymor.operators.constructions.LowRankUpdatedOperator`. For the latter,
:meth:`~pymor.operators.interfaces.OperatorInterface.apply_inverse` and
:meth:`~pymor.operators.interfaces.OperatorInterface.apply_inverse_adjoint` are implemented
via the Sherman-Morrison-Woodbury formula `[#743] <https://github.com/pymor/pymor/pull/743>`_.
Improved string representations of pyMOR objects
Custom `__str__` special methods have been implemented for all |Model| classes shipped with
pyMOR `[#652] <https://github.com/pymor/pymor/pull/652>`_. Moreover, we have added a generic
`__repr__` implementation to `BasicInterface` which recursively prints all class attributes
corresponding to an `__init__` argument (with a non-default value)
`[#706] <https://github.com/pymor/pymor/pull/706>`_.
Easier working with immutable objects
A new check in :class:`~pymor.core.interfaces.ImmutableMeta` enforces all `__init__` arguments
of an |immutable| object to be available as object attributes, thus ensuring that
`~pymor.core.interfaces.ImmutableInterface.with_` works reliably with all |immutable| objects
in pyMOR `[#694] <https://github.com/pymor/pymor/pull/694>`_. To facilitate the initialization
of these attributes in `__init__` the
`__auto_init <https://github.com/pymor/pymor/pull/732/files#diff-9ff4f0e773ee7352ff323cb88a3adeabR149-R164>`_
method has been added to `BasicInterface` `[#732] <https://github.com/pymor/pymor/pull/732>`_.
Finally, `~pymor.core.interfaces.ImmutableInterface.with_` now has a `new_type` parameter
which allows to change the class of the object returned by it
`[#705] <https://github.com/pymor/pymor/pull/705>`_.
project and assemble_lincomb are easier to extend
In pyMOR 0.5, we have introduced |RuleTables| to make central algorithms in
pyMOR, like the projection of an |Operator| via |project|, easier to trace and
For pyMOR 2019.2, we have further simplified |project| by removing the `product`
argument from the underlying |RuleTable| `[#785] <https://github.com/pymor/pymor/pull/785>`_.
As the inheritance-based implementation of `assemble_lincomb` was showing similar
complexity issues as the old inheritance-based implementation of `projected`, we
moved all backend-agnostic logic into the |RuleTable|-based free function
:func:`~pymor.algorithms.lincomb.assemble_lincomb`, leaving the remaining backend
code in :meth:`~pymor.operators.interfaces.OperatorInterface._assemble_lincomb`
`[#619] <https://github.com/pymor/pymor/pull/619>`_.
Improvements to pyMOR's discretization toolbox
pyMOR's builtin discretization toolbox as seen multiple minor improvements:
- `[#821] Enable to have parametric dirichlet in fv <https://github.com/pymor/pymor/pull/821>`_
- `[#687] Discretizing robin boundary conditions on a RectGrid <https://github.com/pymor/pymor/pull/687>`_
- `[#691] Remove 'order' arguments from CG operators <https://github.com/pymor/pymor/pull/691>`_
- `[#760] [discretizers.cg] affine decomposition of robin operator and rhs functionals <https://github.com/pymor/pymor/pull/760>`_
- `[#793] Use meshio for Gmsh file parsing <https://github.com/pymor/pymor/pull/793>`_
Backward incompatible changes
Dropped Python 3.5 support
As Python 3.6 or newer now ships with the current versions of all major Linux distributions,
we have decided to drop support for Python 3.6 in pyMOR 2019.2. This allows us to benefit
from new language features, in particular f-strings and class attribute definition order
preservation `[#553] <https://github.com/pymor/pymor/pull/553>`_,
`[#584] <https://github.com/pymor/pymor/pull/553>`_.
Global RandomState
pyMOR now has a (mutable) global default :class:`~numpy.random.RandomState`. This means
that when :meth:`~pymor.parameters.spaces.CubicParameterSpace.sample_randomly` is called
repeatedly without specifying a `random_state` or `seed` argument, different |Parameter|
samples will be returned in contrast to the (surprising) previous behavior where the
same samples would have been returned. The same :class:`~numpy.random.RandomState` is
used by the newly introduced :meth:`~pymor.vectorarrays.interfaces.VectorArrayInterface.random`
method of the :class:`~pymor.vectorarrays.interfaces.VectorArrayInterface`
`[#620] <https://github.com/pymor/pymor/pull/620>`_.
Space id handling
The usage of |VectorSpace| :attr:`ids <pymor.vectorarrays.interfaces.VectorSpace.id>` in pyMOR
has been reduced throughout pyMOR to avoid unwanted errors due to incompatible |VectorSpaces|
(that only differ by their id):
- `[#611] [models.iosys] remove space id handling except for factory methods <https://github.com/pymor/pymor/pull/611>`_
- `[#613] Remove VectorSpace id handling from projection methods <https://github.com/pymor/pymor/pull/613>`_
- `[#614] Remove id from BlockVectorSpace <https://github.com/pymor/pymor/pull/614>`_
- `[#615] Remove 'space' parameter from as_vector <https://github.com/pymor/pymor/pull/615>`_
Further API Changes
- The stagnation criterion of the :func:`~pymor.algorithms.newton.newton` is disabled by default
(and a relaxation parameter has been added) `[#800] <https://github.com/pymor/pymor/pull/800>`_.
- The `coordinates` parameter of :class:`~pymor.parameters.functionals.ProjectionParameterFunctional`
has been renamed to `index` `[#756] <https://github.com/pymor/pymor/pull/756>`_.
Further notable improvements
- `[#559] fix arnoldi when E is not identity <https://github.com/pymor/pymor/pull/559>`_
- `[#569] Fix NonProjectedResidualOperator.apply <https://github.com/pymor/pymor/pull/569>`_
- `[#585] implement MPIOperator.apply_inverse_adjoint <https://github.com/pymor/pymor/pull/585>`_
- `[#607] Replace sqlite caching <https://github.com/pymor/pymor/pull/607>`_
- `[#608] [mpi] small tweaks to make MPI wrapping more flexible <https://github.com/pymor/pymor/pull/608>`_
- `[#627] Fix as_source_array/as_range_array for BlockRowOperator/BlockColumnOperator <https://github.com/pymor/pymor/pull/627>`_
- `[#644] Replace numpy.linalg.solve by scipy.linalg.solve <https://github.com/pymor/pymor/pull/644>`_
- `[#663] [NumpyVectorSpace] fix issue 662 <https://github.com/pymor/pymor/pull/663>`_
- `[#668] Fixed complex norms <https://github.com/pymor/pymor/pull/668>`_
- `[#693] [parameters.functionals] implement __neg__ <https://github.com/pymor/pymor/pull/693>`_
- `[#702] Add 'linear' attribute to StationaryModel and InstationaryModel <https://github.com/pymor/pymor/pull/702>`_