def solve_pos_ricc_lrcf(A,
E,
B,
C,
R=None,
S=None,
trans=False,
options=None):
"""Compute an approximate low-rank solution of a positive Riccati equation.
See :func:`pymor.algorithms.riccati.solve_pos_ricc_lrcf` for a
general description.
This function uses `slycot.sb02md` (if E and S are `None`),
`slycot.sb02od` (if E is `None` and S is not `None`) and
`slycot.sg03ad` (if E is not `None`), which are dense solvers.
Therefore, we assume all |Operators| and |VectorArrays| can be
converted to |NumPy arrays| using
:func:`~pymor.algorithms.to_matrix.to_matrix` and
:func:`~pymor.vectorarrays.interfaces.VectorArrayInterface.to_numpy`.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
C
The operator C as a |VectorArray| from `A.source`.
R
The operator R as a 2D |NumPy array| or `None`.
S
The operator S as a |VectorArray| from `A.source` or `None`.
trans
Whether the first |Operator| in the positive Riccati
equation is transposed.
options
The solver options to use (see
:func:`pos_ricc_lrcf_solver_options`).
Returns
-------
Z
Low-rank Cholesky factor of the positive Riccati equation
solution, |VectorArray| from `A.source`.
"""
_solve_ricc_check_args(A, E, B, C, R, S, trans)
options = _parse_options(options, pos_ricc_lrcf_solver_options(),
'slycot', None, False)
if options['type'] != 'slycot':
raise ValueError(
f"Unexpected positive Riccati equation solver ({options['type']})."
)
if R is None:
R = np.eye(len(C) if not trans else len(B))
return solve_ricc_lrcf(A, E, B, C, -R, S, trans, options)
def solve_ricc_lrcf(A, E, B, C, R=None, trans=False, options=None):
"""Compute an approximate low-rank solution of a Riccati equation.
See :func:`pymor.algorithms.riccati.solve_ricc_lrcf` for a general
description.
This function uses `scipy.linalg.solve_continuous_are`, which
is a dense solver.
Therefore, we assume all |Operators| and |VectorArrays| can be
converted to |NumPy arrays| using
:func:`~pymor.algorithms.to_matrix.to_matrix` and
:func:`~pymor.vectorarrays.interface.VectorArray.to_numpy`.
Parameters
----------
A
The non-parametric |Operator| A.
E
The non-parametric |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
C
The operator C as a |VectorArray| from `A.source`.
R
The operator R as a 2D |NumPy array| or `None`.
trans
Whether the first |Operator| in the Riccati equation is
transposed.
options
The solver options to use (see :func:`ricc_lrcf_solver_options`).
Returns
-------
Z
Low-rank Cholesky factor of the Riccati equation solution,
|VectorArray| from `A.source`.
"""
_solve_ricc_check_args(A, E, B, C, R, trans)
options = _parse_options(options, ricc_lrcf_solver_options(), 'scipy',
None, False)
if options['type'] != 'scipy':
raise ValueError(
f"Unexpected Riccati equation solver ({options['type']}).")
A_source = A.source
A = to_matrix(A, format='dense')
E = to_matrix(E, format='dense') if E else None
B = B.to_numpy().T
C = C.to_numpy()
if R is None:
R = np.eye(C.shape[0] if not trans else B.shape[1])
if not trans:
if E is not None:
E = E.T
X = solve_continuous_are(A.T, C.T, B.dot(B.T), R, E)
else:
X = solve_continuous_are(A, B, C.T.dot(C), R, E)
return A_source.from_numpy(_chol(X).T)
def solve_lyap_dense(A, E, B, trans=False, options=None):
"""Compute the solution of a Lyapunov equation.
See :func:`pymor.algorithms.lyapunov.solve_lyap_dense` for a
general description.
This function uses `slycot.sb03md` (if `E is None`) and
`slycot.sg03ad` (if `E is not None`), which are based on the
Bartels-Stewart algorithm.
Parameters
----------
A
The operator A as a 2D |NumPy array|.
E
The operator E as a 2D |NumPy array| or `None`.
B
The operator B as a 2D |NumPy array|.
trans
Whether the first operator in the Lyapunov equation is
transposed.
options
The solver options to use (see
:func:`lyap_dense_solver_options`).
Returns
-------
X
Lyapunov equation solution as a |NumPy array|.
"""
_solve_lyap_dense_check_args(A, E, B, trans)
options = _parse_options(options, lyap_dense_solver_options(), 'slycot_bartels-stewart', None, False)
if options['type'] == 'slycot_bartels-stewart':
n = A.shape[0]
C = -B.dot(B.T) if not trans else -B.T.dot(B)
trana = 'T' if not trans else 'N'
dico = 'C'
job = 'B'
if E is None:
U = np.zeros((n, n))
X, scale, sep, ferr, _ = slycot.sb03md(n, C, A, U, dico, job=job, trana=trana)
_solve_check(A.dtype, 'slycot.sb03md', sep, ferr)
else:
fact = 'N'
uplo = 'L'
Q = np.zeros((n, n))
Z = np.zeros((n, n))
_, _, _, _, X, scale, sep, ferr, _, _, _ = slycot.sg03ad(dico, job, fact, trana, uplo,
n, A, E,
Q, Z, C)
_solve_check(A.dtype, 'slycot.sg03ad', sep, ferr)
X /= scale
else:
raise ValueError(f"Unexpected Lyapunov equation solver ({options['type']}).")
return X
def solve_lyap_dense(A, E, B, trans=False, options=None):
"""Compute the solution of a Lyapunov equation.
See :func:`pymor.algorithms.lyapunov.solve_lyap_dense` for a
general description.
This function uses `slycot.sb03md` (if `E is None`) and
`slycot.sg03ad` (if `E is not None`), which are based on the
Bartels-Stewart algorithm.
Parameters
----------
A
The operator A as a 2D |NumPy array|.
E
The operator E as a 2D |NumPy array| or `None`.
B
The operator B as a 2D |NumPy array|.
trans
Whether the first operator in the Lyapunov equation is
transposed.
options
The solver options to use (see
:func:`lyap_dense_solver_options`).
Returns
-------
X
Lyapunov equation solution as a |NumPy array|.
"""
_solve_lyap_dense_check_args(A, E, B, trans)
options = _parse_options(options, lyap_dense_solver_options(), 'slycot_bartels-stewart', None, False)
if options['type'] == 'slycot_bartels-stewart':
n = A.shape[0]
C = -B.dot(B.T) if not trans else -B.T.dot(B)
trana = 'T' if not trans else 'N'
dico = 'C'
job = 'B'
if E is None:
U = np.zeros((n, n))
X, scale, sep, ferr, _ = slycot.sb03md(n, C, A, U, dico, job=job, trana=trana)
_solve_check(A.dtype, 'slycot.sb03md', sep, ferr)
else:
fact = 'N'
uplo = 'L'
Q = np.zeros((n, n))
Z = np.zeros((n, n))
_, _, _, _, X, scale, sep, ferr, _, _, _ = slycot.sg03ad(dico, job, fact, trana, uplo,
n, A, E,
Q, Z, C)
_solve_check(A.dtype, 'slycot.sg03ad', sep, ferr)
X /= scale
else:
raise ValueError(f"Unexpected Lyapunov equation solver ({options['type']}).")
return X
def solve_pos_ricc_lrcf(A, E, B, C, R=None, trans=False, options=None):
"""Compute an approximate low-rank solution of a positive Riccati equation.
See :func:`pymor.algorithms.riccati.solve_pos_ricc_lrcf` for a
general description.
This function uses `pymess.dense_nm_gmpcare`.
Parameters
----------
A
The non-parametric |Operator| A.
E
The non-parametric |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
C
The operator C as a |VectorArray| from `A.source`.
R
The operator R as a 2D |NumPy array| or `None`.
trans
Whether the first |Operator| in the Riccati equation is
transposed.
options
The solver options to use (see
:func:`pos_ricc_lrcf_solver_options`).
Returns
-------
Z
Low-rank Cholesky factor of the Riccati equation solution,
|VectorArray| from `A.source`.
"""
_solve_ricc_check_args(A, E, B, C, R, trans)
options = _parse_options(options, pos_ricc_lrcf_solver_options(),
'pymess_dense_nm_gmpcare', None, False)
if options['type'] == 'pymess_dense_nm_gmpcare':
X = _call_pymess_dense_nm_gmpare(A,
E,
B,
C,
R,
trans=trans,
options=options['opts'],
plus=True,
method_name='solve_pos_ricc_lrcf')
Z = _chol(X)
else:
raise ValueError(
f'Unexpected positive Riccati equation solver ({options["type"]}).'
)
return A.source.from_numpy(Z.T)
def solve_lyap_dense(A, E, B, trans=False, options=None):
"""Compute the solution of a Lyapunov equation.
See :func:`pymor.algorithms.lyapunov.solve_lyap_dense` for a
general description.
This function uses `scipy.linalg.solve_continuous_lyapunov`, which
is a dense solver for Lyapunov equations with E=I.
.. note::
If E is not `None`, the problem will be reduced to a standard
continuous-time algebraic Lyapunov equation by inverting E.
Parameters
----------
A
The operator A as a 2D |NumPy array|.
E
The operator E as a 2D |NumPy array| or `None`.
B
The operator B as a 2D |NumPy array|.
trans
Whether the first operator in the Lyapunov equation is
transposed.
options
The solver options to use (see
:func:`lyap_dense_solver_options`).
Returns
-------
X
Lyapunov equation solution as a |NumPy array|.
"""
_solve_lyap_dense_check_args(A, E, B, trans)
options = _parse_options(options, lyap_dense_solver_options(), 'scipy',
None, False)
if options['type'] == 'scipy':
if E is not None:
A = solve(E, A) if not trans else solve(E.T, A.T).T
B = solve(E, B) if not trans else solve(E.T, B.T).T
if trans:
A = A.T
B = B.T
X = solve_continuous_lyapunov(A, -B.dot(B.T))
else:
raise ValueError(
f"Unexpected Lyapunov equation solver ({options['type']}).")
return X
def solve_lyap_lrcf(A, E, B, trans=False, options=None):
"""Compute an approximate low-rank solution of a Lyapunov equation.
See :func:`pymor.algorithms.lyapunov.solve_lyap_lrcf` for a
general description.
This function uses `slycot.sb03md` (if `E is None`) and
`slycot.sg03ad` (if `E is not None`), which are dense solvers
based on the Bartels-Stewart algorithm.
Therefore, we assume A and E can be converted to |NumPy arrays|
using :func:`~pymor.algorithms.to_matrix.to_matrix` and that
`B.to_numpy` is implemented.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
trans
Whether the first |Operator| in the Lyapunov equation is
transposed.
options
The solver options to use (see
:func:`lyap_lrcf_solver_options`).
Returns
-------
Z
Low-rank Cholesky factor of the Lyapunov equation solution,
|VectorArray| from `A.source`.
"""
_solve_lyap_lrcf_check_args(A, E, B, trans)
options = _parse_options(options, lyap_lrcf_solver_options(),
'slycot_bartels-stewart', None, False)
if options['type'] == 'slycot_bartels-stewart':
X = solve_lyap_dense(to_matrix(A, format='dense'),
to_matrix(E, format='dense') if E else None,
B.to_numpy().T if not trans else B.to_numpy(),
trans=trans,
options=options)
Z = _chol(X)
else:
raise ValueError(
f"Unexpected Lyapunov equation solver ({options['type']}).")
return A.source.from_numpy(Z.T)
def solve_pos_ricc_lrcf(A, E, B, C, R=None, S=None, trans=False, options=None):
"""Compute an approximate low-rank solution of a positive Riccati equation.
See :func:`pymor.algorithms.riccati.solve_pos_ricc_lrcf` for a
general description.
This function uses `slycot.sb02md` (if E and S are `None`),
`slycot.sb02od` (if E is `None` and S is not `None`) and
`slycot.sg03ad` (if E is not `None`), which are dense solvers.
Therefore, we assume all |Operators| and |VectorArrays| can be
converted to |NumPy arrays| using
:func:`~pymor.algorithms.to_matrix.to_matrix` and
:func:`~pymor.vectorarrays.interfaces.VectorArrayInterface.to_numpy`.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
C
The operator C as a |VectorArray| from `A.source`.
R
The operator R as a 2D |NumPy array| or `None`.
S
The operator S as a |VectorArray| from `A.source` or `None`.
trans
Whether the first |Operator| in the positive Riccati
equation is transposed.
options
The solver options to use (see
:func:`pos_ricc_lrcf_solver_options`).
Returns
-------
Z
Low-rank Cholesky factor of the positive Riccati equation
solution, |VectorArray| from `A.source`.
"""
_solve_ricc_check_args(A, E, B, C, R, S, trans)
options = _parse_options(options, pos_ricc_lrcf_solver_options(), 'slycot', None, False)
if options['type'] != 'slycot':
raise ValueError(f"Unexpected positive Riccati equation solver ({options['type']}).")
if R is None:
R = np.eye(len(C) if not trans else len(B))
return solve_ricc_lrcf(A, E, B, C, -R, S, trans, options)
def solve_lyap_dense(A, E, B, trans=False, options=None):
"""Compute the solution of a Lyapunov equation.
See :func:`pymor.algorithms.lyapunov.solve_lyap_dense` for a
general description.
This function uses `scipy.linalg.solve_continuous_lyapunov`, which
is a dense solver for Lyapunov equations with E=I.
.. note::
If E is not `None`, the problem will be reduced to a standard
continuous-time algebraic Lyapunov equation by inverting E.
Parameters
----------
A
The operator A as a 2D |NumPy array|.
E
The operator E as a 2D |NumPy array| or `None`.
B
The operator B as a 2D |NumPy array|.
trans
Whether the first operator in the Lyapunov equation is
transposed.
options
The solver options to use (see
:func:`lyap_dense_solver_options`).
Returns
-------
X
Lyapunov equation solution as a |NumPy array|.
"""
_solve_lyap_dense_check_args(A, E, B, trans)
options = _parse_options(options, lyap_dense_solver_options(), 'scipy', None, False)
if options['type'] == 'scipy':
if E is not None:
A = solve(E, A) if not trans else solve(E.T, A.T).T
B = solve(E, B) if not trans else solve(E.T, B.T).T
if trans:
A = A.T
B = B.T
X = solve_continuous_lyapunov(A, -B.dot(B.T))
else:
raise ValueError(f"Unexpected Lyapunov equation solver ({options['type']}).")
return X
def solve_lyap(A, E, B, trans=False, options=None):
"""Find a factor of the solution of a Lyapunov equation.
Returns factor :math:`Z` such that :math:`Z Z^T` is approximately
the solution :math:`X` of a Lyapunov equation (if E is `None`).
.. math::
A X + X A^T + B B^T = 0
or generalized Lyapunov equation
.. math::
A X E^T + E X A^T + B B^T = 0.
If trans is `True`, then solve (if E is `None`)
.. math::
A^T X + X A + B^T B = 0
or
.. math::
A^T X E + E^T X A + B^T B = 0.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The |Operator| B.
trans
If the dual equation needs to be solved.
options
The |solver_options| to use (see :func:`lyap_solver_options`).
Returns
-------
Z
Low-rank factor of the Lyapunov equation solution, |VectorArray| from `A.source`.
"""
_solve_lyap_check_args(A, E, B, trans)
options = _parse_options(options, lyap_solver_options(), 'lradi', None, False)
if options['type'] == 'lradi':
return lradi(A, E, B, trans, options)
else:
raise ValueError('Unknown solver type')
def solve_lyap_lrcf(A, E, B, trans=False, options=None):
"""Compute an approximate low-rank solution of a Lyapunov equation.
See :func:`pymor.algorithms.lyapunov.solve_lyap_lrcf` for a general
description.
This function uses `scipy.linalg.solve_continuous_lyapunov`, which
is a dense solver for Lyapunov equations with E=I.
Therefore, we assume A and E can be converted to |NumPy arrays|
using :func:`~pymor.algorithms.to_matrix.to_matrix` and that
`B.to_numpy` is implemented.
.. note::
If E is not `None`, the problem will be reduced to a standard
continuous-time algebraic Lyapunov equation by inverting E.
Parameters
----------
A
The non-parametric |Operator| A.
E
The non-parametric |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
trans
Whether the first |Operator| in the Lyapunov equation is
transposed.
options
The solver options to use (see
:func:`lyap_lrcf_solver_options`).
Returns
-------
Z
Low-rank Cholesky factor of the Lyapunov equation solution,
|VectorArray| from `A.source`.
"""
_solve_lyap_lrcf_check_args(A, E, B, trans)
options = _parse_options(options, lyap_lrcf_solver_options(), 'scipy',
None, False)
X = solve_lyap_dense(to_matrix(A, format='dense'),
to_matrix(E, format='dense') if E else None,
B.to_numpy().T if not trans else B.to_numpy(),
trans=trans,
options=options)
return A.source.from_numpy(_chol(X).T)
def solve_lyap_lrcf(A, E, B, trans=False, options=None):
"""Compute an approximate low-rank solution of a Lyapunov equation.
See :func:`pymor.algorithms.lyapunov.solve_lyap_lrcf` for a
general description.
This function uses `slycot.sb03md` (if `E is None`) and
`slycot.sg03ad` (if `E is not None`), which are dense solvers
based on the Bartels-Stewart algorithm.
Therefore, we assume A and E can be converted to |NumPy arrays|
using :func:`~pymor.algorithms.to_matrix.to_matrix` and that
`B.to_numpy` is implemented.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
trans
Whether the first |Operator| in the Lyapunov equation is
transposed.
options
The solver options to use (see
:func:`lyap_lrcf_solver_options`).
Returns
-------
Z
Low-rank Cholesky factor of the Lyapunov equation solution,
|VectorArray| from `A.source`.
"""
_solve_lyap_lrcf_check_args(A, E, B, trans)
options = _parse_options(options, lyap_lrcf_solver_options(), 'slycot_bartels-stewart', None, False)
if options['type'] == 'slycot_bartels-stewart':
X = solve_lyap_dense(to_matrix(A, format='dense'),
to_matrix(E, format='dense') if E else None,
B.to_numpy().T if not trans else B.to_numpy(),
trans=trans, options=options)
Z = _chol(X)
else:
raise ValueError(f"Unexpected Lyapunov equation solver ({options['type']}).")
return A.source.from_numpy(Z.T)
def solve_pos_ricc_lrcf(A, E, B, C, R=None, S=None, trans=False, options=None):
"""Compute an approximate low-rank solution of a positive Riccati equation.
See :func:`pymor.algorithms.riccati.solve_pos_ricc_lrcf` for a
general description.
This function uses `pymess.dense_nm_gmpcare`.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
C
The operator C as a |VectorArray| from `A.source`.
R
The operator R as a 2D |NumPy array| or `None`.
S
The operator S as a |VectorArray| from `A.source` or `None`.
trans
Whether the first |Operator| in the Riccati equation is
transposed.
options
The solver options to use (see
:func:`pos_ricc_lrcf_solver_options`).
Returns
-------
Z
Low-rank Cholesky factor of the Riccati equation solution,
|VectorArray| from `A.source`.
"""
_solve_ricc_check_args(A, E, B, C, R, S, trans)
options = _parse_options(options, pos_ricc_lrcf_solver_options(), 'pymess_dense_nm_gmpcare', None, False)
if options['type'] == 'pymess_dense_nm_gmpcare':
X = _call_pymess_dense_nm_gmpare(A, E, B, C, R, S, trans=trans, options=options['opts'], plus=True)
Z = _chol(X)
else:
raise ValueError(f'Unexpected positive Riccati equation solver ({options["type"]}).')
return A.source.from_numpy(Z.T)
def solve_lyap_lrcf(A, E, B, trans=False, options=None):
"""Compute an approximate low-rank solution of a Lyapunov equation.
See :func:`pymor.algorithms.lyapunov.solve_lyap_lrcf` for a general
description.
This function uses `scipy.linalg.solve_continuous_lyapunov`, which
is a dense solver for Lyapunov equations with E=I.
Therefore, we assume A and E can be converted to |NumPy arrays|
using :func:`~pymor.algorithms.to_matrix.to_matrix` and that
`B.to_numpy` is implemented.
.. note::
If E is not `None`, the problem will be reduced to a standard
continuous-time algebraic Lyapunov equation by inverting E.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
trans
Whether the first |Operator| in the Lyapunov equation is
transposed.
options
The solver options to use (see
:func:`lyap_lrcf_solver_options`).
Returns
-------
Z
Low-rank Cholesky factor of the Lyapunov equation solution,
|VectorArray| from `A.source`.
"""
_solve_lyap_lrcf_check_args(A, E, B, trans)
options = _parse_options(options, lyap_lrcf_solver_options(), 'scipy', None, False)
X = solve_lyap_dense(to_matrix(A, format='dense'),
to_matrix(E, format='dense') if E else None,
B.to_numpy().T if not trans else B.to_numpy(),
trans=trans, options=options)
return A.source.from_numpy(_chol(X).T)
def solve_lyap_dense(A, E, B, trans=False, options=None):
"""Compute the solution of a Lyapunov equation.
See :func:`pymor.algorithms.lyapunov.solve_lyap_dense` for a
general description.
This function uses `pymess.glyap`.
Parameters
----------
A
The operator A as a 2D |NumPy array|.
E
The operator E as a 2D |NumPy array| or `None`.
B
The operator B as a 2D |NumPy array|.
trans
Whether the first operator in the Lyapunov equation is
transposed.
options
The solver options to use (see
:func:`lyap_dense_solver_options`).
Returns
-------
X
Lyapunov equation solution as a |NumPy array|.
"""
_solve_lyap_dense_check_args(A, E, B, trans)
options = _parse_options(options, lyap_lrcf_solver_options(),
'pymess_glyap', None, False)
if options['type'] == 'pymess_glyap':
Y = B.dot(B.T) if not trans else B.T.dot(B)
op = pymess.MESS_OP_NONE if not trans else pymess.MESS_OP_TRANSPOSE
X = pymess.glyap(A, E, Y, op=op)[0]
X = np.asarray(X)
else:
raise ValueError(
f'Unexpected Lyapunov equation solver ({options["type"]}).')
return X
def solve_lyap_dense(A, E, B, trans=False, options=None):
"""Compute the solution of a Lyapunov equation.
See :func:`pymor.algorithms.lyapunov.solve_lyap_dense` for a
general description.
This function uses `pymess.glyap`.
Parameters
----------
A
The operator A as a 2D |NumPy array|.
E
The operator E as a 2D |NumPy array| or `None`.
B
The operator B as a 2D |NumPy array|.
trans
Whether the first operator in the Lyapunov equation is
transposed.
options
The solver options to use (see
:func:`lyap_dense_solver_options`).
Returns
-------
X
Lyapunov equation solution as a |NumPy array|.
"""
_solve_lyap_dense_check_args(A, E, B, trans)
options = _parse_options(options, lyap_lrcf_solver_options(), 'pymess_glyap', None, False)
if options['type'] == 'pymess_glyap':
Y = B.dot(B.T) if not trans else B.T.dot(B)
op = pymess.MESS_OP_NONE if not trans else pymess.MESS_OP_TRANSPOSE
X = pymess.glyap(A, E, Y, op=op)[0]
else:
raise ValueError(f'Unexpected Lyapunov equation solver ({options["type"]}).')
return X
def solve_ricc_lrcf(A, E, B, C, R=None, S=None, trans=False, options=None):
"""Compute an approximate low-rank solution of a Riccati equation.
See :func:`pymor.algorithms.riccati.solve_ricc_lrcf` for a
general description.
This function uses `slycot.sb02md` (if E and S are `None`),
`slycot.sb02od` (if E is `None` and S is not `None`) and
`slycot.sg03ad` (if E is not `None`), which are dense solvers.
Therefore, we assume all |Operators| and |VectorArrays| can be
converted to |NumPy arrays| using
:func:`~pymor.algorithms.to_matrix.to_matrix` and
:func:`~pymor.vectorarrays.interfaces.VectorArrayInterface.to_numpy`.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
C
The operator C as a |VectorArray| from `A.source`.
R
The operator R as a 2D |NumPy array| or `None`.
S
The operator S as a |VectorArray| from `A.source` or `None`.
trans
Whether the first |Operator| in the Riccati equation is
transposed.
options
The solver options to use (see
:func:`ricc_lrcf_solver_options`).
Returns
-------
Z
Low-rank Cholesky factor of the Riccati equation solution,
|VectorArray| from `A.source`.
"""
_solve_ricc_check_args(A, E, B, C, R, S, trans)
options = _parse_options(options, ricc_lrcf_solver_options(), 'slycot',
None, False)
if options['type'] != 'slycot':
raise ValueError(
f"Unexpected Riccati equation solver ({options['type']}).")
A_source = A.source
A = to_matrix(A, format='dense')
E = to_matrix(E, format='dense') if E else None
B = B.to_numpy().T
C = C.to_numpy()
S = S.to_numpy().T if S else None
n = A.shape[0]
dico = 'C'
if E is None:
if S is None:
if not trans:
A = A.T
G = C.T.dot(C) if R is None else slycot.sb02mt(
n, C.shape[0], C.T, R)[-1]
else:
G = B.dot(B.T) if R is None else slycot.sb02mt(
n, B.shape[1], B, R)[-1]
Q = B.dot(B.T) if not trans else C.T.dot(C)
X, rcond = slycot.sb02md(n, A, G, Q, dico)[:2]
_ricc_rcond_check('slycot.sb02md', rcond)
else:
m = C.shape[0] if not trans else B.shape[1]
p = B.shape[1] if not trans else C.shape[0]
if R is None:
R = np.eye(m)
if not trans:
A = A.T
B, C = C.T, B.T
X, rcond = slycot.sb02od(n,
m,
A,
B,
C,
R,
dico,
p=p,
L=S,
fact='C')[:2]
_ricc_rcond_check('slycot.sb02od', rcond)
else:
jobb = 'B'
fact = 'C'
uplo = 'U'
jobl = 'Z' if S is None else 'N'
scal = 'N'
sort = 'S'
acc = 'R'
m = C.shape[0] if not trans else B.shape[1]
p = B.shape[1] if not trans else C.shape[0]
if R is None:
R = np.eye(m)
if S is None:
S = np.empty((n, m))
if not trans:
A = A.T
E = E.T
B, C = C.T, B.T
out = slycot.sg02ad(dico, jobb, fact, uplo, jobl, scal, sort, acc,
n, m, p, A, E, B, C, R, S)
X = out[1]
rcond = out[0]
_ricc_rcond_check('slycot.sg02ad', rcond)
return A_source.from_numpy(_chol(X).T)
def solve_ricc_lrcf(A, E, B, C, R=None, S=None, trans=False, options=None, default_solver=None):
"""Compute an approximate low-rank solution of a Riccati equation.
See :func:`pymor.algorithms.riccati.solve_ricc_lrcf` for a
general description.
This function uses `pymess.dense_nm_gmpcare` and `pymess.lrnm`.
For both methods,
:meth:`~pymor.vectorarrays.interfaces.VectorArrayInterface.to_numpy`
and
:meth:`~pymor.vectorarrays.interfaces.VectorSpaceInterface.from_numpy`
need to be implemented for `A.source`.
Additionally, since `dense_nm_gmpcare` is a dense solver, it
expects :func:`~pymor.algorithms.to_matrix.to_matrix` to work
for A and E.
If the solver is not specified using the options or
default_solver arguments, `dense_nm_gmpcare` is used for small
problems (smaller than defined with
:func:`~pymor.algorithms.lyapunov.mat_eqn_sparse_min_size`) and
`lrnm` for large problems.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
C
The operator C as a |VectorArray| from `A.source`.
R
The operator R as a 2D |NumPy array| or `None`.
S
The operator S as a |VectorArray| from `A.source` or `None`.
trans
Whether the first |Operator| in the Riccati equation is
transposed.
options
The solver options to use (see
:func:`ricc_lrcf_solver_options`).
default_solver
Default solver to use (pymess_lrnm,
pymess_dense_nm_gmpcare).
If `None`, chose solver depending on dimension `A`.
Returns
-------
Z
Low-rank Cholesky factor of the Riccati equation solution,
|VectorArray| from `A.source`.
"""
_solve_ricc_check_args(A, E, B, C, R, S, trans)
if default_solver is None:
default_solver = 'pymess_lrnm' if A.source.dim >= mat_eqn_sparse_min_size() else 'pymess_dense_nm_gmpcare'
options = _parse_options(options, ricc_lrcf_solver_options(), default_solver, None, False)
if options['type'] == 'pymess_dense_nm_gmpcare':
X = _call_pymess_dense_nm_gmpare(A, E, B, C, R, S, trans=trans, options=options['opts'], plus=False)
Z = _chol(X)
elif options['type'] == 'pymess_lrnm':
if S is not None:
raise NotImplementedError
if R is not None:
import scipy.linalg as spla
Rc = spla.cholesky(R) # R = Rc^T * Rc
Rci = spla.solve_triangular(Rc, np.eye(Rc.shape[0])) # R^{-1} = Rci * Rci^T
if not trans:
C = C.lincomb(Rci.T) # C <- Rci^T * C = (C^T * Rci)^T
else:
B = B.lincomb(Rci.T) # B <- B * Rci
opts = options['opts']
opts.type = pymess.MESS_OP_NONE if not trans else pymess.MESS_OP_TRANSPOSE
eqn = RiccatiEquation(opts, A, E, B, C)
Z, status = pymess.lrnm(eqn, opts)
else:
raise ValueError(f'Unexpected Riccati equation solver ({options["type"]}).')
return A.source.from_numpy(Z.T)
def solve_ricc(A, E=None, B=None, Q=None, C=None, R=None, G=None,
trans=False, options=None):
"""Find a factor of the solution of a Riccati equation using solve_continuous_are.
Returns factor :math:`Z` such that :math:`Z Z^T` is approximately
the solution :math:`X` of a Riccati equation
.. math::
A^T X E + E^T X A - E^T X B R^{-1} B^T X E + Q = 0.
If E in `None`, it is taken to be the identity matrix.
Q can instead be given as C^T * C. In this case, Q needs to be
`None`, and C not `None`.
B * R^{-1} B^T can instead be given by G. In this case, B and R need
to be `None`, and G not `None`.
If R and G are `None`, then R is taken to be the identity matrix.
If trans is `True`, then the dual Riccati equation is solved
.. math::
A X E^T + E X A^T - E X C^T R^{-1} C X E^T + Q = 0,
where Q can be replaced by B * B^T and C^T * R^{-1} * C by G.
This uses the `scipy.linalg.spla.solve_continuous_are` method.
Generalized Riccati equation is not supported.
It can only solve medium-sized dense problems and assumes access to
the matrix data of all operators.
Parameters
----------
A
The |Operator| A.
B
The |Operator| B or `None`.
E
The |Operator| E or `None`.
Q
The |Operator| Q or `None`.
C
The |Operator| C or `None`.
R
The |Operator| R or `None`.
G
The |Operator| G or `None`.
trans
If the dual equation needs to be solved.
options
The |solver_options| to use (see :func:`ricc_solver_options`).
Returns
-------
Z
Low-rank factor of the Riccati equation solution,
|VectorArray| from `A.source`.
"""
_solve_ricc_check_args(A, E, B, Q, C, R, G, trans)
options = _parse_options(options, lyap_solver_options(), 'scipy', None, False)
assert options['type'] == 'scipy'
if E is not None or G is not None:
raise NotImplementedError
import scipy.linalg as spla
A_mat = to_matrix(A, format='dense')
B_mat = to_matrix(B, format='dense') if B else None
C_mat = to_matrix(C, format='dense') if C else None
Q_mat = to_matrix(Q, format='dense') if Q else None
R_mat = to_matrix(R, format='dense') if R else None
if R is None:
if not trans:
R_mat = np.eye(B.source.dim)
else:
R_mat = np.eye(C.range.dim)
if not trans:
if Q is None:
Q_mat = C_mat.T.dot(C_mat)
X = spla.solve_continuous_are(A_mat, B_mat, Q_mat, R_mat)
else:
if Q is None:
Q_mat = B_mat.dot(B_mat.T)
X = spla.solve_continuous_are(A_mat.T, C_mat.T, Q_mat, R_mat)
Z = chol(X, copy=False)
Z = A.source.from_numpy(np.array(Z).T)
return Z
def apply_inverse(op,
V,
initial_guess=None,
options=None,
least_squares=False,
check_finite=True,
default_solver='scipy_spsolve',
default_least_squares_solver='scipy_least_squares_lsmr'):
"""Solve linear equation system.
Applies the inverse of `op` to the vectors in `V` using SciPy.
Parameters
----------
op
The linear, non-parametric |Operator| to invert.
V
|VectorArray| of right-hand sides for the equation system.
initial_guess
|VectorArray| with the same length as `V` containing initial guesses
for the solution. Some implementations of `apply_inverse` may
ignore this parameter. If `None` a solver-dependent default is used.
options
The |solver_options| to use (see :func:`solver_options`).
least_squares
If `True`, return least squares solution.
check_finite
Test if solution only contains finite values.
default_solver
Default solver to use (scipy_spsolve, scipy_bicgstab, scipy_bicgstab_spilu,
scipy_lgmres, scipy_least_squares_lsmr, scipy_least_squares_lsqr).
default_least_squares_solver
Default solver to use for least squares problems (scipy_least_squares_lsmr,
scipy_least_squares_lsqr).
Returns
-------
|VectorArray| of the solution vectors.
"""
assert V in op.range
assert initial_guess is None or initial_guess in op.source and len(
initial_guess) == len(V)
if isinstance(op, NumpyMatrixOperator):
matrix = op.matrix
else:
from pymor.algorithms.to_matrix import to_matrix
matrix = to_matrix(op)
options = _parse_options(options, solver_options(), default_solver,
default_least_squares_solver, least_squares)
V = V.to_numpy()
initial_guess = initial_guess.to_numpy(
) if initial_guess is not None else None
promoted_type = np.promote_types(matrix.dtype, V.dtype)
R = np.empty((len(V), matrix.shape[1]), dtype=promoted_type)
if options['type'] == 'scipy_bicgstab':
for i, VV in enumerate(V):
R[i], info = bicgstab(
matrix,
VV,
initial_guess[i] if initial_guess is not None else None,
tol=options['tol'],
maxiter=options['maxiter'])
if info != 0:
if info > 0:
raise InversionError(
f'bicgstab failed to converge after {info} iterations')
else:
raise InversionError(
'bicgstab failed with error code {} (illegal input or breakdown)'
.format(info))
elif options['type'] == 'scipy_bicgstab_spilu':
ilu = spilu(matrix,
drop_tol=options['spilu_drop_tol'],
fill_factor=options['spilu_fill_factor'],
drop_rule=options['spilu_drop_rule'],
permc_spec=options['spilu_permc_spec'])
precond = LinearOperator(matrix.shape, ilu.solve)
for i, VV in enumerate(V):
R[i], info = bicgstab(
matrix,
VV,
initial_guess[i] if initial_guess is not None else None,
tol=options['tol'],
maxiter=options['maxiter'],
M=precond)
if info != 0:
if info > 0:
raise InversionError(
f'bicgstab failed to converge after {info} iterations')
else:
raise InversionError(
'bicgstab failed with error code {} (illegal input or breakdown)'
.format(info))
elif options['type'] == 'scipy_spsolve':
try:
# maybe remove unusable factorization:
if hasattr(matrix, 'factorization'):
fdtype = matrix.factorizationdtype
if not np.can_cast(V.dtype, fdtype, casting='safe'):
del matrix.factorization
if hasattr(matrix, 'factorization'):
# we may use a complex factorization of a real matrix to
# apply it to a real vector. In that case, we downcast
# the result here, removing the imaginary part,
# which should be zero.
R = matrix.factorization.solve(V.T).T.astype(promoted_type,
copy=False)
elif options['keep_factorization']:
# the matrix is always converted to the promoted type.
# if matrix.dtype == promoted_type, this is a no_op
matrix.factorization = splu(matrix_astype_nocopy(
matrix.tocsc(), promoted_type),
permc_spec=options['permc_spec'])
matrix.factorizationdtype = promoted_type
R = matrix.factorization.solve(V.T).T
else:
# the matrix is always converted to the promoted type.
# if matrix.dtype == promoted_type, this is a no_op
R = spsolve(matrix_astype_nocopy(matrix, promoted_type),
V.T,
permc_spec=options['permc_spec']).T
except RuntimeError as e:
raise InversionError(e)
elif options['type'] == 'scipy_lgmres':
for i, VV in enumerate(V):
R[i], info = lgmres(
matrix,
VV,
initial_guess[i] if initial_guess is not None else None,
tol=options['tol'],
atol=options['tol'],
maxiter=options['maxiter'],
inner_m=options['inner_m'],
outer_k=options['outer_k'])
if info > 0:
raise InversionError(
f'lgmres failed to converge after {info} iterations')
assert info == 0
elif options['type'] == 'scipy_least_squares_lsmr':
from scipy.sparse.linalg import lsmr
for i, VV in enumerate(V):
R[i], info, itn, _, _, _, _, _ = lsmr(
matrix,
VV,
damp=options['damp'],
atol=options['atol'],
btol=options['btol'],
conlim=options['conlim'],
maxiter=options['maxiter'],
show=options['show'],
x0=initial_guess[i] if initial_guess is not None else None)
assert 0 <= info <= 7
if info == 7:
raise InversionError(
f'lsmr failed to converge after {itn} iterations')
elif options['type'] == 'scipy_least_squares_lsqr':
for i, VV in enumerate(V):
R[i], info, itn, _, _, _, _, _, _, _ = lsqr(
matrix,
VV,
damp=options['damp'],
atol=options['atol'],
btol=options['btol'],
conlim=options['conlim'],
iter_lim=options['iter_lim'],
show=options['show'],
x0=initial_guess[i] if initial_guess is not None else None)
assert 0 <= info <= 7
if info == 7:
raise InversionError(
f'lsmr failed to converge after {itn} iterations')
else:
raise ValueError('Unknown solver type')
if check_finite:
if not np.isfinite(np.sum(R)):
raise InversionError('Result contains non-finite values')
return op.source.from_numpy(R)
def solve_lyap_lrcf(A, E, B, trans=False, options=None):
"""Compute an approximate low-rank solution of a Lyapunov equation.
See :func:`pymor.algorithms.lyapunov.solve_lyap_lrcf` for a
general description.
This function uses the low-rank ADI iteration as described in
Algorithm 4.3 in [PK16]_.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
trans
Whether the first |Operator| in the Lyapunov equation is
transposed.
options
The solver options to use (see
:func:`lyap_lrcf_solver_options`).
Returns
-------
Z
Low-rank Cholesky factor of the Lyapunov equation solution,
|VectorArray| from `A.source`.
"""
_solve_lyap_lrcf_check_args(A, E, B, trans)
options = _parse_options(options, lyap_lrcf_solver_options(), 'lradi',
None, False)
logger = getLogger('pymor.algorithms.lradi.solve_lyap_lrcf')
shift_options = options['shift_options'][options['shifts']]
if shift_options['type'] == 'projection_shifts':
init_shifts = projection_shifts_init
iteration_shifts = projection_shifts
else:
raise ValueError('Unknown lradi shift strategy.')
if E is None:
E = IdentityOperator(A.source)
Z = A.source.empty(reserve=len(B) * options['maxiter'])
W = B.copy()
j = 0
j_shift = 0
shifts = init_shifts(A, E, W, shift_options)
res = np.linalg.norm(W.gramian(), ord=2)
init_res = res
Btol = res * options['tol']
while res > Btol and j < options['maxiter']:
if shifts[j_shift].imag == 0:
AaE = A + shifts[j_shift].real * E
if not trans:
V = AaE.apply_inverse(W)
W -= E.apply(V) * (2 * shifts[j_shift].real)
else:
V = AaE.apply_inverse_adjoint(W)
W -= E.apply_adjoint(V) * (2 * shifts[j_shift].real)
Z.append(V * np.sqrt(-2 * shifts[j_shift].real))
j += 1
else:
AaE = A + shifts[j_shift] * E
gs = -4 * shifts[j_shift].real
d = shifts[j_shift].real / shifts[j_shift].imag
if not trans:
V = AaE.apply_inverse(W)
W += E.apply(V.real + V.imag * d) * gs
else:
V = AaE.apply_inverse_adjoint(W).conj()
W += E.apply_adjoint(V.real + V.imag * d) * gs
g = np.sqrt(gs)
Z.append((V.real + V.imag * d) * g)
Z.append(V.imag * (g * np.sqrt(d**2 + 1)))
j += 2
j_shift += 1
res = np.linalg.norm(W.gramian(), ord=2)
logger.info(f'Relative residual at step {j}: {res/init_res:.5e}')
if j_shift >= shifts.size:
shifts = iteration_shifts(A, E, V, shifts)
j_shift = 0
if res > Btol:
logger.warning(
f'Prescribed relative residual tolerance was not achieved '
f'({res/init_res:e} > {options["tol"]:e}) after '
f'{options["maxiter"]} ADI steps.')
return Z
def solve_lyap(A, E, B, trans=False, options=None):
"""Find a factor of the solution of a Lyapunov equation.
Returns factor :math:`Z` such that :math:`Z Z^T` is approximately
the solution :math:`X` of a Lyapunov equation (if E is `None`).
.. math::
A X + X A^T + B B^T = 0
or generalized Lyapunov equation
.. math::
A X E^T + E X A^T + B B^T = 0.
If trans is `True`, then it solves (if E is `None`)
.. math::
A^T X + X A + B^T B = 0
or
.. math::
A^T X E + E^T X A + B^T B = 0.
This uses the `scipy.linalg.spla.solve_continuous_lyapunov` method.
It is only applicable to the standard Lyapunov equation (E = I).
Furthermore, it can only solve medium-sized dense problems and
assumes access to the matrix data of all operators.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The |Operator| B.
trans
If the dual equation needs to be solved.
options
The |solver_options| to use (see :func:`lyap_solver_options`).
Returns
-------
Z
Low-rank factor of the Lyapunov equation solution, |VectorArray|
from `A.source`.
"""
_solve_lyap_check_args(A, E, B, trans)
options = _parse_options(options, lyap_solver_options(), 'scipy', None, False)
assert options['type'] == 'scipy'
if E is not None:
raise NotImplementedError
import scipy.linalg as spla
A_mat = to_matrix(A, format='dense')
B_mat = to_matrix(B, format='dense')
if not trans:
X = spla.solve_continuous_lyapunov(A_mat, -B_mat.dot(B_mat.T))
else:
X = spla.solve_continuous_lyapunov(A_mat.T, -B_mat.T.dot(B_mat))
Z = chol(X, copy=False)
Z = A.source.from_numpy(np.array(Z).T)
return Z
def solve_ricc(A, E=None, B=None, Q=None, C=None, R=None, G=None, trans=False, options=None):
"""Find a factor of the solution of a Riccati equation
Returns factor :math:`Z` such that :math:`Z Z^T` is
approximately the solution :math:`X` of a Riccati equation
.. math::
A^T X E + E^T X A - E^T X B R^{-1} B^T X E + Q = 0.
If E in `None`, it is taken to be the identity matrix.
Q can instead be given as C^T * C. In this case, Q needs to be
`None`, and C not `None`.
B * R^{-1} B^T can instead be given by G. In this case, B and R
need to be `None`, and G not `None`.
If R and G are `None`, then R is taken to be the identity
matrix.
If trans is `True`, then the dual Riccati equation is solved
.. math::
A X E^T + E X A^T - E X C^T R^{-1} C X E^T + Q = 0,
where Q can be replaced by B * B^T and C^T * R^{-1} * C by G.
This uses the `slycot` package, in particular its interfaces to
SLICOT functions `SB02MD` (for the standard Riccati equations)
and `SG02AD` (for the generalized Riccati equations).
These methods are only applicable to medium-sized dense
problems and need access to the matrix data of all operators.
Parameters
----------
A
The |Operator| A.
B
The |Operator| B or `None`.
E
The |Operator| E or `None`.
Q
The |Operator| Q or `None`.
C
The |Operator| C or `None`.
R
The |Operator| R or `None`.
G
The |Operator| G or `None`.
trans
If the dual equation needs to be solved.
options
The |solver_options| to use (see
:func:`ricc_solver_options`).
Returns
-------
Z
Low-rank factor of the Riccati equation solution,
|VectorArray| from `A.source`.
"""
_solve_ricc_check_args(A, E, B, Q, C, R, G, trans)
options = _parse_options(options, ricc_solver_options(), 'slycot', None, False)
assert options['type'] == 'slycot'
import slycot
A_mat = to_matrix(A, format='dense')
B_mat = to_matrix(B, format='dense') if B else None
C_mat = to_matrix(C, format='dense') if C else None
R_mat = to_matrix(R, format='dense') if R else None
G_mat = to_matrix(G, format='dense') if G else None
Q_mat = to_matrix(Q, format='dense') if Q else None
n = A_mat.shape[0]
dico = 'C'
if E is None:
if not trans:
if G is None:
if R is None:
G_mat = B_mat.dot(B_mat.T)
else:
G_mat = slycot.sb02mt(n, B_mat.shape[1], B_mat, R_mat)[-1]
if C is not None:
Q_mat = C_mat.T.dot(C_mat)
X = slycot.sb02md(n, A_mat, G_mat, Q_mat, dico)[0]
else:
if G is None:
if R is None:
G_mat = C_mat.T.dot(C_mat)
else:
G_mat = slycot.sb02mt(n, C_mat.shape[0], C_mat.T, R_mat)[-1]
if B is not None:
Q_mat = B_mat.dot(B_mat.T)
X = slycot.sb02md(n, A_mat.T, G_mat, Q_mat, dico)[0]
else:
E_mat = to_matrix(E, format='dense') if E else None
jobb = 'B' if G is None else 'B'
fact = 'C' if Q is None else 'N'
uplo = 'U'
jobl = 'Z'
scal = 'N'
sort = 'S'
acc = 'R'
if not trans:
m = 0 if B is None else B_mat.shape[1]
p = 0 if C is None else C_mat.shape[0]
if G is not None:
B_mat = G_mat
R_mat = np.empty((1, 1))
elif R is None:
R_mat = np.eye(m)
if Q is None:
Q_mat = C_mat
L_mat = np.empty((n, m))
ret = slycot.sg02ad(dico, jobb, fact, uplo, jobl, scal, sort, acc, n, m, p,
A_mat, E_mat, B_mat, Q_mat, R_mat, L_mat)
else:
m = 0 if C is None else C_mat.shape[0]
p = 0 if B is None else B_mat.shape[1]
if G is not None:
C_mat = G_mat
R_mat = np.empty((1, 1))
elif R is None:
C_mat = C_mat.T
R_mat = np.eye(m)
else:
C_mat = C_mat.T
if Q is None:
Q_mat = B_mat.T
L_mat = np.empty((n, m))
ret = slycot.sg02ad(dico, jobb, fact, uplo, jobl, scal, sort, acc, n, m, p,
A_mat.T, E_mat.T, C_mat, Q_mat, R_mat, L_mat)
X = ret[1]
iwarn = ret[-1]
if iwarn == 1:
print('slycot.sg02ad warning: solution may be inaccurate.')
from pymor.bindings.scipy import chol
Z = chol(X, copy=False)
Z = A.source.from_numpy(np.array(Z).T)
return Z
def solve_ricc(A, E=None, B=None, Q=None, C=None, R=None, G=None,
trans=False, options=None, default_solver='pymess'):
"""Find a factor of the solution of a Riccati equation
Returns factor :math:`Z` such that :math:`Z Z^T` is
approximately the solution :math:`X` of a Riccati equation
.. math::
A^T X E + E^T X A - E^T X B R^{-1} B^T X E + Q = 0.
If E in `None`, it is taken to be the identity matrix.
Q can instead be given as C^T * C. In this case, Q needs to be
`None`, and C not `None`.
B * R^{-1} B^T can instead be given by G. In this case, B and R
need to be `None`, and G not `None`.
If R and G are `None`, then R is taken to be the identity
matrix.
If trans is `True`, then the dual Riccati equation is solved
.. math::
A X E^T + E X A^T - E X C^T R^{-1} C X E^T + Q = 0,
where Q can be replaced by B * B^T and C^T * R^{-1} * C by G.
This uses the `pymess` package, in particular its `care` and
`lrnm` methods.
Operators Q, R, and G are not supported,
Both methods can be used for large-scale problems.
The restrictions are:
- `care` needs access to all matrix data, i.e., it expects
:func:`~pymor.algorithms.to_matrix.to_matrix` to work for
A, E, B, and C,
- `lrnm` needs access to the data of the operators B and C,
i.e., it expects
:func:`~pymor.algorithms.to_matrix.to_matrix` to work for
B and C.
Parameters
----------
A
The |Operator| A.
B
The |Operator| B or `None`.
E
The |Operator| E or `None`.
Q
The |Operator| Q or `None`.
C
The |Operator| C or `None`.
R
The |Operator| R or `None`.
G
The |Operator| G or `None`.
trans
If the dual equation needs to be solved.
options
The |solver_options| to use (see
:func:`ricc_solver_options`).
default_solver
The solver to use when no `options` are specified (pymess,
pymess_care, pymess_lrnm).
Returns
-------
Z
Low-rank factor of the Riccati equation solution,
|VectorArray| from `A.source`.
"""
_solve_ricc_check_args(A, E, B, Q, C, R, G, trans)
options = _parse_options(options, ricc_solver_options(), default_solver, None, False)
if options['type'] == 'pymess':
if A.source.dim >= PYMESS_MIN_SPARSE_SIZE:
options = dict(options, type='pymess_lrnm') # do not modify original dict!
else:
options = dict(options, type='pymess_care') # do not modify original dict!
if options['type'] == 'pymess_care':
if Q is not None or R is not None or G is not None:
raise NotImplementedError
A_mat = to_matrix(A, format='dense') if A.source.dim < PYMESS_MIN_SPARSE_SIZE else to_matrix(A)
if E is not None:
E_mat = to_matrix(E, format='dense') if A.source.dim < PYMESS_MIN_SPARSE_SIZE else to_matrix(E)
else:
E_mat = None
B_mat = to_matrix(B, format='dense') if B else None
C_mat = to_matrix(C, format='dense') if C else None
if not trans:
Z = pymess.care(A_mat, E_mat, B_mat, C_mat)
else:
if E is None:
Z = pymess.care(A_mat.T, None, C_mat.T, B_mat.T)
else:
Z = pymess.care(A_mat.T, E_mat.T, C_mat.T, B_mat.T)
elif options['type'] == 'pymess_lrnm':
if Q is not None or R is not None or G is not None:
raise NotImplementedError
opts = options['opts']
if not trans:
opts.type = pymess.MESS_OP_TRANSPOSE
else:
opts.type = pymess.MESS_OP_NONE
eqn = RiccatiEquation(opts, A, E, B, C)
Z, status = pymess.lrnm(eqn, opts)
Z = A.source.from_numpy(np.array(Z).T)
return Z
def solve_ricc_lrcf(A, E, B, C, R=None, S=None, trans=False, options=None):
"""Compute an approximate low-rank solution of a Riccati equation.
See :func:`pymor.algorithms.riccati.solve_ricc_lrcf` for a
general description.
This function uses `slycot.sb02md` (if E and S are `None`),
`slycot.sb02od` (if E is `None` and S is not `None`) and
`slycot.sg03ad` (if E is not `None`), which are dense solvers.
Therefore, we assume all |Operators| and |VectorArrays| can be
converted to |NumPy arrays| using
:func:`~pymor.algorithms.to_matrix.to_matrix` and
:func:`~pymor.vectorarrays.interfaces.VectorArrayInterface.to_numpy`.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
C
The operator C as a |VectorArray| from `A.source`.
R
The operator R as a 2D |NumPy array| or `None`.
S
The operator S as a |VectorArray| from `A.source` or `None`.
trans
Whether the first |Operator| in the Riccati equation is
transposed.
options
The solver options to use (see
:func:`ricc_lrcf_solver_options`).
Returns
-------
Z
Low-rank Cholesky factor of the Riccati equation solution,
|VectorArray| from `A.source`.
"""
_solve_ricc_check_args(A, E, B, C, R, S, trans)
options = _parse_options(options, ricc_lrcf_solver_options(), 'slycot', None, False)
if options['type'] != 'slycot':
raise ValueError(f"Unexpected Riccati equation solver ({options['type']}).")
A_source = A.source
A = to_matrix(A, format='dense')
E = to_matrix(E, format='dense') if E else None
B = B.to_numpy().T
C = C.to_numpy()
S = S.to_numpy().T if S else None
n = A.shape[0]
dico = 'C'
if E is None:
if S is None:
if not trans:
A = A.T
G = C.T.dot(C) if R is None else slycot.sb02mt(n, C.shape[0], C.T, R)[-1]
else:
G = B.dot(B.T) if R is None else slycot.sb02mt(n, B.shape[1], B, R)[-1]
Q = B.dot(B.T) if not trans else C.T.dot(C)
X, rcond = slycot.sb02md(n, A, G, Q, dico)[:2]
_ricc_rcond_check('slycot.sb02md', rcond)
else:
m = C.shape[0] if not trans else B.shape[1]
p = B.shape[1] if not trans else C.shape[0]
if R is None:
R = np.eye(m)
if not trans:
A = A.T
B, C = C.T, B.T
X, rcond = slycot.sb02od(n, m, A, B, C, R, dico, p=p, L=S, fact='C')[:2]
_ricc_rcond_check('slycot.sb02od', rcond)
else:
jobb = 'B'
fact = 'C'
uplo = 'U'
jobl = 'Z' if S is None else 'N'
scal = 'N'
sort = 'S'
acc = 'R'
m = C.shape[0] if not trans else B.shape[1]
p = B.shape[1] if not trans else C.shape[0]
if R is None:
R = np.eye(m)
if S is None:
S = np.empty((n, m))
if not trans:
A = A.T
E = E.T
B, C = C.T, B.T
out = slycot.sg02ad(dico, jobb, fact, uplo, jobl, scal, sort, acc,
n, m, p,
A, E, B, C, R, S)
X = out[1]
rcond = out[0]
_ricc_rcond_check('slycot.sg02ad', rcond)
return A_source.from_numpy(_chol(X).T)
def apply_inverse(op,
V,
options=None,
least_squares=False,
check_finite=True,
default_solver='scipy_spsolve',
default_least_squares_solver='scipy_least_squares_lsmr'):
"""Solve linear equation system.
Applies the inverse of `op` to the vectors in `rhs` using PyAMG.
Parameters
----------
op
The linear, non-parametric |Operator| to invert.
rhs
|VectorArray| of right-hand sides for the equation system.
options
The |solver_options| to use (see :func:`solver_options`).
check_finite
Test if solution only containes finite values.
default_solver
Default solver to use (scipy_spsolve, scipy_bicgstab, scipy_bicgstab_spilu,
scipy_lgmres, scipy_least_squares_lsmr, scipy_least_squares_lsqr).
default_least_squares_solver
Default solver to use for least squares problems (scipy_least_squares_lsmr,
scipy_least_squares_lsqr).
Returns
-------
|VectorArray| of the solution vectors.
"""
assert V in op.range
if isinstance(op, NumpyMatrixOperator):
matrix = op._matrix
else:
from pymor.algorithms.to_matrix import to_matrix
matrix = to_matrix(op)
options = _parse_options(options, solver_options(), default_solver,
default_least_squares_solver, least_squares)
V = V.data
promoted_type = np.promote_types(matrix.dtype, V.dtype)
R = np.empty((len(V), matrix.shape[1]), dtype=promoted_type)
if options['type'] == 'scipy_bicgstab':
for i, VV in enumerate(V):
R[i], info = bicgstab(matrix,
VV,
tol=options['tol'],
maxiter=options['maxiter'])
if info != 0:
if info > 0:
raise InversionError(
'bicgstab failed to converge after {} iterations'.
format(info))
else:
raise InversionError(
'bicgstab failed with error code {} (illegal input or breakdown)'
.format(info))
elif options['type'] == 'scipy_bicgstab_spilu':
if Version(scipy.version.version) >= Version('0.19'):
ilu = spilu(matrix,
drop_tol=options['spilu_drop_tol'],
fill_factor=options['spilu_fill_factor'],
drop_rule=options['spilu_drop_rule'],
permc_spec=options['spilu_permc_spec'])
else:
if options['spilu_drop_rule']:
logger = getLogger('pymor.operators.numpy._apply_inverse')
logger.error(
"ignoring drop_rule in ilu factorization due to old SciPy")
ilu = spilu(matrix,
drop_tol=options['spilu_drop_tol'],
fill_factor=options['spilu_fill_factor'],
permc_spec=options['spilu_permc_spec'])
precond = LinearOperator(matrix.shape, ilu.solve)
for i, VV in enumerate(V):
R[i], info = bicgstab(matrix,
VV,
tol=options['tol'],
maxiter=options['maxiter'],
M=precond)
if info != 0:
if info > 0:
raise InversionError(
'bicgstab failed to converge after {} iterations'.
format(info))
else:
raise InversionError(
'bicgstab failed with error code {} (illegal input or breakdown)'
.format(info))
elif options['type'] == 'scipy_spsolve':
try:
# maybe remove unusable factorization:
if hasattr(matrix, 'factorization'):
fdtype = matrix.factorizationdtype
if not np.can_cast(V.dtype, fdtype, casting='safe'):
del matrix.factorization
if Version(scipy.version.version) >= Version('0.14'):
if hasattr(matrix, 'factorization'):
# we may use a complex factorization of a real matrix to
# apply it to a real vector. In that case, we downcast
# the result here, removing the imaginary part,
# which should be zero.
R = matrix.factorization.solve(V.T).T.astype(promoted_type,
copy=False)
elif options['keep_factorization']:
# the matrix is always converted to the promoted type.
# if matrix.dtype == promoted_type, this is a no_op
matrix.factorization = splu(
matrix_astype_nocopy(matrix.tocsc(), promoted_type),
permc_spec=options['permc_spec'])
matrix.factorizationdtype = promoted_type
R = matrix.factorization.solve(V.T).T
else:
# the matrix is always converted to the promoted type.
# if matrix.dtype == promoted_type, this is a no_op
R = spsolve(matrix_astype_nocopy(matrix, promoted_type),
V.T,
permc_spec=options['permc_spec']).T
else:
# see if-part for documentation
if hasattr(matrix, 'factorization'):
for i, VV in enumerate(V):
R[i] = matrix.factorization.solve(VV).astype(
promoted_type, copy=False)
elif options['keep_factorization']:
matrix.factorization = splu(
matrix_astype_nocopy(matrix.tocsc(), promoted_type),
permc_spec=options['permc_spec'])
matrix.factorizationdtype = promoted_type
for i, VV in enumerate(V):
R[i] = matrix.factorization.solve(VV)
elif len(V) > 1:
factorization = splu(matrix_astype_nocopy(
matrix.tocsc(), promoted_type),
permc_spec=options['permc_spec'])
for i, VV in enumerate(V):
R[i] = factorization.solve(VV)
else:
R = spsolve(matrix_astype_nocopy(matrix, promoted_type),
V.T,
permc_spec=options['permc_spec']).reshape(
(1, -1))
except RuntimeError as e:
raise InversionError(e)
elif options['type'] == 'scipy_lgmres':
for i, VV in enumerate(V):
R[i], info = lgmres(matrix,
VV,
tol=options['tol'],
maxiter=options['maxiter'],
inner_m=options['inner_m'],
outer_k=options['outer_k'])
if info > 0:
raise InversionError(
'lgmres failed to converge after {} iterations'.format(
info))
assert info == 0
elif options['type'] == 'scipy_least_squares_lsmr':
from scipy.sparse.linalg import lsmr
for i, VV in enumerate(V):
R[i], info, itn, _, _, _, _, _ = lsmr(matrix,
VV,
damp=options['damp'],
atol=options['atol'],
btol=options['btol'],
conlim=options['conlim'],
maxiter=options['maxiter'],
show=options['show'])
assert 0 <= info <= 7
if info == 7:
raise InversionError(
'lsmr failed to converge after {} iterations'.format(itn))
elif options['type'] == 'scipy_least_squares_lsqr':
for i, VV in enumerate(V):
R[i], info, itn, _, _, _, _, _, _, _ = lsqr(
matrix,
VV,
damp=options['damp'],
atol=options['atol'],
btol=options['btol'],
conlim=options['conlim'],
iter_lim=options['iter_lim'],
show=options['show'])
assert 0 <= info <= 7
if info == 7:
raise InversionError(
'lsmr failed to converge after {} iterations'.format(itn))
else:
raise ValueError('Unknown solver type')
if check_finite:
if not np.isfinite(np.sum(R)):
raise InversionError('Result contains non-finite values')
return op.source.from_data(R)
def solve_ricc_lrcf(A, E, B, C, R=None, S=None, trans=False, options=None):
"""Compute an approximate low-rank solution of a Riccati equation.
See :func:`pymor.algorithms.riccati.solve_ricc_lrcf` for a
general description.
This function is an implementation of Algorithm 2 in [BBKS18]_.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
C
The operator C as a |VectorArray| from `A.source`.
R
The operator R as a 2D |NumPy array| or `None`.
S
The operator S as a |VectorArray| from `A.source` or `None`.
trans
Whether the first |Operator| in the Riccati equation is
transposed.
options
The solver options to use. (see
:func:`ricc_lrcf_solver_options`)
Returns
-------
Z
Low-rank Cholesky factor of the Riccati equation solution,
|VectorArray| from `A.source`.
"""
_solve_ricc_check_args(A, E, B, C, None, None, trans)
options = _parse_options(options, ricc_lrcf_solver_options(), 'lrradi',
None, False)
logger = getLogger('pymor.algorithms.lrradi.solve_ricc_lrcf')
shift_options = options['shift_options'][options['shifts']]
if shift_options['type'] == 'hamiltonian_shifts':
init_shifts = hamiltonian_shifts_init
iteration_shifts = hamiltonian_shifts
else:
raise ValueError('Unknown lrradi shift strategy.')
if E is None:
E = IdentityOperator(A.source)
if S is not None:
raise NotImplementedError
if R is not None:
Rc = spla.cholesky(R) # R = Rc^T * Rc
Rci = spla.solve_triangular(Rc, np.eye(
Rc.shape[0])) # R^{-1} = Rci * Rci^T
if not trans:
C = C.lincomb(Rci.T) # C <- Rci^T * C = (C^T * Rci)^T
else:
B = B.lincomb(Rci.T) # B <- B * Rci
if not trans:
B, C = C, B
Z = A.source.empty(reserve=len(C) * options['maxiter'])
Y = np.empty((0, 0))
K = A.source.zeros(len(B))
RF = C.copy()
j = 0
j_shift = 0
shifts = init_shifts(A, E, B, C, shift_options)
res = np.linalg.norm(RF.gramian(), ord=2)
init_res = res
Ctol = res * options['tol']
while res > Ctol and j < options['maxiter']:
if not trans:
AsE = A + shifts[j_shift] * E
else:
AsE = A + np.conj(shifts[j_shift]) * E
if j == 0:
if not trans:
V = AsE.apply_inverse(RF) * np.sqrt(-2 * shifts[j_shift].real)
else:
V = AsE.apply_inverse_adjoint(RF) * np.sqrt(
-2 * shifts[j_shift].real)
else:
if not trans:
LN = AsE.apply_inverse(cat_arrays([RF, K]))
else:
LN = AsE.apply_inverse_adjoint(cat_arrays([RF, K]))
L = LN[:len(RF)]
N = LN[-len(K):]
ImBN = np.eye(len(K)) - B.dot(N)
ImBNKL = spla.solve(ImBN, B.dot(L))
V = (L + N.lincomb(ImBNKL.T)) * np.sqrt(-2 * shifts[j_shift].real)
if np.imag(shifts[j_shift]) == 0:
Z.append(V)
VB = V.dot(B)
Yt = np.eye(len(C)) - (VB @ VB.T) / (2 * shifts[j_shift].real)
Y = spla.block_diag(Y, Yt)
if not trans:
EVYt = E.apply(V).lincomb(np.linalg.inv(Yt))
else:
EVYt = E.apply_adjoint(V).lincomb(np.linalg.inv(Yt))
RF.axpy(np.sqrt(-2 * shifts[j_shift].real), EVYt)
K += EVYt.lincomb(VB.T)
j += 1
else:
Z.append(V.real)
Z.append(V.imag)
Vr = V.real.dot(B)
Vi = V.imag.dot(B)
sa = np.abs(shifts[j_shift])
F1 = np.vstack((-shifts[j_shift].real / sa * Vr -
shifts[j_shift].imag / sa * Vi,
shifts[j_shift].imag / sa * Vr -
shifts[j_shift].real / sa * Vi))
F2 = np.vstack((Vr, Vi))
F3 = np.vstack((shifts[j_shift].imag / sa * np.eye(len(C)),
shifts[j_shift].real / sa * np.eye(len(C))))
Yt = spla.block_diag(np.eye(len(C)), 0.5 * np.eye(len(C))) \
- (F1 @ F1.T) / (4 * shifts[j_shift].real) \
- (F2 @ F2.T) / (4 * shifts[j_shift].real) \
- (F3 @ F3.T) / 2
Y = spla.block_diag(Y, Yt)
EVYt = E.apply(cat_arrays([V.real,
V.imag])).lincomb(np.linalg.inv(Yt))
RF.axpy(np.sqrt(-2 * shifts[j_shift].real), EVYt[:len(C)])
K += EVYt.lincomb(F2.T)
j += 2
j_shift += 1
res = np.linalg.norm(RF.gramian(), ord=2)
logger.info(f'Relative residual at step {j}: {res/init_res:.5e}')
if j_shift >= shifts.size:
shifts = iteration_shifts(A, E, B, RF, K, Z, shift_options)
j_shift = 0
# transform solution to lrcf
cf = spla.cholesky(Y)
Z_cf = Z.lincomb(spla.solve_triangular(cf, np.eye(len(Z))).T)
return Z_cf
def apply_inverse(op, V, options=None, least_squares=False, check_finite=True,
default_solver='scipy_spsolve', default_least_squares_solver='scipy_least_squares_lsmr'):
"""Solve linear equation system.
Applies the inverse of `op` to the vectors in `rhs` using PyAMG.
Parameters
----------
op
The linear, non-parametric |Operator| to invert.
rhs
|VectorArray| of right-hand sides for the equation system.
options
The |solver_options| to use (see :func:`solver_options`).
check_finite
Test if solution only containes finite values.
default_solver
Default solver to use (scipy_spsolve, scipy_bicgstab, scipy_bicgstab_spilu,
scipy_lgmres, scipy_least_squares_lsmr, scipy_least_squares_lsqr).
default_least_squares_solver
Default solver to use for least squares problems (scipy_least_squares_lsmr,
scipy_least_squares_lsqr).
Returns
-------
|VectorArray| of the solution vectors.
"""
assert V in op.range
if isinstance(op, NumpyMatrixOperator):
matrix = op._matrix
else:
from pymor.algorithms.to_matrix import to_matrix
matrix = to_matrix(op)
options = _parse_options(options, solver_options(), default_solver, default_least_squares_solver, least_squares)
V = V.data
promoted_type = np.promote_types(matrix.dtype, V.dtype)
R = np.empty((len(V), matrix.shape[1]), dtype=promoted_type)
if options['type'] == 'scipy_bicgstab':
for i, VV in enumerate(V):
R[i], info = bicgstab(matrix, VV, tol=options['tol'], maxiter=options['maxiter'])
if info != 0:
if info > 0:
raise InversionError('bicgstab failed to converge after {} iterations'.format(info))
else:
raise InversionError('bicgstab failed with error code {} (illegal input or breakdown)'.
format(info))
elif options['type'] == 'scipy_bicgstab_spilu':
if Version(scipy.version.version) >= Version('0.19'):
ilu = spilu(matrix, drop_tol=options['spilu_drop_tol'], fill_factor=options['spilu_fill_factor'],
drop_rule=options['spilu_drop_rule'], permc_spec=options['spilu_permc_spec'])
else:
if options['spilu_drop_rule']:
logger = getLogger('pymor.operators.numpy._apply_inverse')
logger.error("ignoring drop_rule in ilu factorization due to old SciPy")
ilu = spilu(matrix, drop_tol=options['spilu_drop_tol'], fill_factor=options['spilu_fill_factor'],
permc_spec=options['spilu_permc_spec'])
precond = LinearOperator(matrix.shape, ilu.solve)
for i, VV in enumerate(V):
R[i], info = bicgstab(matrix, VV, tol=options['tol'], maxiter=options['maxiter'], M=precond)
if info != 0:
if info > 0:
raise InversionError('bicgstab failed to converge after {} iterations'.format(info))
else:
raise InversionError('bicgstab failed with error code {} (illegal input or breakdown)'.
format(info))
elif options['type'] == 'scipy_spsolve':
try:
# maybe remove unusable factorization:
if hasattr(matrix, 'factorization'):
fdtype = matrix.factorizationdtype
if not np.can_cast(V.dtype, fdtype, casting='safe'):
del matrix.factorization
if Version(scipy.version.version) >= Version('0.14'):
if hasattr(matrix, 'factorization'):
# we may use a complex factorization of a real matrix to
# apply it to a real vector. In that case, we downcast
# the result here, removing the imaginary part,
# which should be zero.
R = matrix.factorization.solve(V.T).T.astype(promoted_type, copy=False)
elif options['keep_factorization']:
# the matrix is always converted to the promoted type.
# if matrix.dtype == promoted_type, this is a no_op
matrix.factorization = splu(matrix_astype_nocopy(matrix.tocsc(), promoted_type),
permc_spec=options['permc_spec'])
matrix.factorizationdtype = promoted_type
R = matrix.factorization.solve(V.T).T
else:
# the matrix is always converted to the promoted type.
# if matrix.dtype == promoted_type, this is a no_op
R = spsolve(matrix_astype_nocopy(matrix, promoted_type), V.T, permc_spec=options['permc_spec']).T
else:
# see if-part for documentation
if hasattr(matrix, 'factorization'):
for i, VV in enumerate(V):
R[i] = matrix.factorization.solve(VV).astype(promoted_type, copy=False)
elif options['keep_factorization']:
matrix.factorization = splu(matrix_astype_nocopy(matrix.tocsc(), promoted_type),
permc_spec=options['permc_spec'])
matrix.factorizationdtype = promoted_type
for i, VV in enumerate(V):
R[i] = matrix.factorization.solve(VV)
elif len(V) > 1:
factorization = splu(matrix_astype_nocopy(matrix.tocsc(), promoted_type),
permc_spec=options['permc_spec'])
for i, VV in enumerate(V):
R[i] = factorization.solve(VV)
else:
R = spsolve(matrix_astype_nocopy(matrix, promoted_type), V.T, permc_spec=options['permc_spec']).reshape((1, -1))
except RuntimeError as e:
raise InversionError(e)
elif options['type'] == 'scipy_lgmres':
for i, VV in enumerate(V):
R[i], info = lgmres(matrix, VV,
tol=options['tol'],
maxiter=options['maxiter'],
inner_m=options['inner_m'],
outer_k=options['outer_k'])
if info > 0:
raise InversionError('lgmres failed to converge after {} iterations'.format(info))
assert info == 0
elif options['type'] == 'scipy_least_squares_lsmr':
from scipy.sparse.linalg import lsmr
for i, VV in enumerate(V):
R[i], info, itn, _, _, _, _, _ = lsmr(matrix, VV,
damp=options['damp'],
atol=options['atol'],
btol=options['btol'],
conlim=options['conlim'],
maxiter=options['maxiter'],
show=options['show'])
assert 0 <= info <= 7
if info == 7:
raise InversionError('lsmr failed to converge after {} iterations'.format(itn))
elif options['type'] == 'scipy_least_squares_lsqr':
for i, VV in enumerate(V):
R[i], info, itn, _, _, _, _, _, _, _ = lsqr(matrix, VV,
damp=options['damp'],
atol=options['atol'],
btol=options['btol'],
conlim=options['conlim'],
iter_lim=options['iter_lim'],
show=options['show'])
assert 0 <= info <= 7
if info == 7:
raise InversionError('lsmr failed to converge after {} iterations'.format(itn))
else:
raise ValueError('Unknown solver type')
if check_finite:
if not np.isfinite(np.sum(R)):
raise InversionError('Result contains non-finite values')
return op.source.from_data(R)
def solve_lyap_lrcf(A,
E,
B,
trans=False,
options=None,
default_solver=None):
"""Compute an approximate low-rank solution of a Lyapunov equation.
See :func:`pymor.algorithms.lyapunov.solve_lyap_lrcf` for a
general description.
This function uses `pymess.glyap` and `pymess.lradi`.
For both methods,
:meth:`~pymor.vectorarrays.interface.VectorArray.to_numpy`
and
:meth:`~pymor.vectorarrays.interface.VectorSpace.from_numpy`
need to be implemented for `A.source`.
Additionally, since `glyap` is a dense solver, it expects
:func:`~pymor.algorithms.to_matrix.to_matrix` to work for A and
E.
If the solver is not specified using the options or
default_solver arguments, `glyap` is used for small problems
(smaller than defined with
:func:`~pymor.algorithms.lyapunov.mat_eqn_sparse_min_size`) and
`lradi` for large problems.
Parameters
----------
A
The non-parametric |Operator| A.
E
The non-parametric |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
trans
Whether the first |Operator| in the Lyapunov equation is
transposed.
options
The solver options to use (see
:func:`lyap_lrcf_solver_options`).
default_solver
Default solver to use (pymess_lradi, pymess_glyap).
If `None`, choose solver depending on the dimension of A.
Returns
-------
Z
Low-rank Cholesky factor of the Lyapunov equation solution,
|VectorArray| from `A.source`.
"""
_solve_lyap_lrcf_check_args(A, E, B, trans)
if default_solver is None:
default_solver = 'pymess_lradi' if A.source.dim >= mat_eqn_sparse_min_size(
) else 'pymess_glyap'
options = _parse_options(options, lyap_lrcf_solver_options(),
default_solver, None, False)
if options['type'] == 'pymess_glyap':
X = solve_lyap_dense(to_matrix(A, format='dense'),
to_matrix(E, format='dense') if E else None,
B.to_numpy().T if not trans else B.to_numpy(),
trans=trans,
options=options)
Z = _chol(X)
elif options['type'] == 'pymess_lradi':
opts = options['opts']
opts.type = pymess.MESS_OP_NONE if not trans else pymess.MESS_OP_TRANSPOSE
eqn = LyapunovEquation(opts, A, E, B)
Z, status = pymess.lradi(eqn, opts)
relres = status.res2_norm / status.res2_0
if relres > opts.adi.res2_tol:
logger = getLogger('pymor.bindings.pymess.solve_lyap_lrcf')
logger.warning(
f'Desired relative residual tolerance was not achieved '
f'({relres:e} > {opts.adi.res2_tol:e}).')
else:
raise ValueError(
f'Unexpected Lyapunov equation solver ({options["type"]}).')
return A.source.from_numpy(Z.T)
def solve_lyap_lrcf(A, E, B, trans=False, options=None, default_solver=None):
"""Compute an approximate low-rank solution of a Lyapunov equation.
See :func:`pymor.algorithms.lyapunov.solve_lyap_lrcf` for a
general description.
This function uses `pymess.glyap` and `pymess.lradi`.
For both methods,
:meth:`~pymor.vectorarrays.interfaces.VectorArrayInterface.to_numpy`
and
:meth:`~pymor.vectorarrays.interfaces.VectorSpaceInterface.from_numpy`
need to be implemented for `A.source`.
Additionally, since `glyap` is a dense solver, it expects
:func:`~pymor.algorithms.to_matrix.to_matrix` to work for A and
E.
If the solver is not specified using the options or
default_solver arguments, `glyap` is used for small problems
(smaller than defined with
:func:`~pymor.algorithms.lyapunov.mat_eqn_sparse_min_size`) and
`lradi` for large problems.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
trans
Whether the first |Operator| in the Lyapunov equation is
transposed.
options
The solver options to use (see
:func:`lyap_lrcf_solver_options`).
default_solver
Default solver to use (pymess_lradi, pymess_glyap).
If `None`, choose solver depending on the dimension of A.
Returns
-------
Z
Low-rank Cholesky factor of the Lyapunov equation solution,
|VectorArray| from `A.source`.
"""
_solve_lyap_lrcf_check_args(A, E, B, trans)
if default_solver is None:
default_solver = 'pymess_lradi' if A.source.dim >= mat_eqn_sparse_min_size() else 'pymess_glyap'
options = _parse_options(options, lyap_lrcf_solver_options(), default_solver, None, False)
if options['type'] == 'pymess_glyap':
X = solve_lyap_dense(to_matrix(A, format='dense'),
to_matrix(E, format='dense') if E else None,
B.to_numpy().T if not trans else B.to_numpy(),
trans=trans, options=options)
Z = _chol(X)
elif options['type'] == 'pymess_lradi':
opts = options['opts']
opts.type = pymess.MESS_OP_NONE if not trans else pymess.MESS_OP_TRANSPOSE
eqn = LyapunovEquation(opts, A, E, B)
Z, status = pymess.lradi(eqn, opts)
else:
raise ValueError(f'Unexpected Lyapunov equation solver ({options["type"]}).')
return A.source.from_numpy(Z.T)
def apply_inverse(op,
V,
options=None,
least_squares=False,
check_finite=True,
default_solver='pyamg_solve'):
"""Solve linear equation system.
Applies the inverse of `op` to the vectors in `rhs` using PyAMG.
Parameters
----------
op
The linear, non-parametric |Operator| to invert.
rhs
|VectorArray| of right-hand sides for the equation system.
options
The |solver_options| to use (see :func:`solver_options`).
least_squares
Must be `False`.
check_finite
Test if solution only contains finite values.
default_solver
Default solver to use (pyamg_solve, pyamg_rs, pyamg_sa).
Returns
-------
|VectorArray| of the solution vectors.
"""
assert V in op.range
if least_squares:
raise NotImplementedError
if isinstance(op, NumpyMatrixOperator):
matrix = op.matrix
else:
from pymor.algorithms.to_matrix import to_matrix
matrix = to_matrix(op)
options = _parse_options(options, solver_options(), default_solver,
None, least_squares)
V = V.to_numpy()
promoted_type = np.promote_types(matrix.dtype, V.dtype)
R = np.empty((len(V), matrix.shape[1]), dtype=promoted_type)
if options['type'] == 'pyamg_solve':
if len(V) > 0:
V_iter = iter(enumerate(V))
R[0], ml = pyamg.solve(matrix,
next(V_iter)[1],
tol=options['tol'],
maxiter=options['maxiter'],
return_solver=True)
for i, VV in V_iter:
R[i] = pyamg.solve(matrix,
VV,
tol=options['tol'],
maxiter=options['maxiter'],
existing_solver=ml)
elif options['type'] == 'pyamg_rs':
ml = pyamg.ruge_stuben_solver(
matrix,
strength=options['strength'],
CF=options['CF'],
presmoother=options['presmoother'],
postsmoother=options['postsmoother'],
max_levels=options['max_levels'],
max_coarse=options['max_coarse'],
coarse_solver=options['coarse_solver'])
for i, VV in enumerate(V):
R[i] = ml.solve(VV,
tol=options['tol'],
maxiter=options['maxiter'],
cycle=options['cycle'],
accel=options['accel'])
elif options['type'] == 'pyamg_sa':
ml = pyamg.smoothed_aggregation_solver(
matrix,
symmetry=options['symmetry'],
strength=options['strength'],
aggregate=options['aggregate'],
smooth=options['smooth'],
presmoother=options['presmoother'],
postsmoother=options['postsmoother'],
improve_candidates=options['improve_candidates'],
max_levels=options['max_levels'],
max_coarse=options['max_coarse'],
diagonal_dominance=options['diagonal_dominance'])
for i, VV in enumerate(V):
R[i] = ml.solve(VV,
tol=options['tol'],
maxiter=options['maxiter'],
cycle=options['cycle'],
accel=options['accel'])
else:
raise ValueError('Unknown solver type')
if check_finite:
if not np.isfinite(np.sum(R)):
raise InversionError('Result contains non-finite values')
return op.source.from_numpy(R)
def solve_lyap(A, E, B, trans=False, options=None, default_solver='pymess'):
"""Find a factor of the solution of a Lyapunov equation.
Returns factor :math:`Z` such that :math:`Z Z^T` is
approximately the solution :math:`X` of a Lyapunov equation (if
E is `None`).
.. math::
A X + X A^T + B B^T = 0
or a generalized Lyapunov equation
.. math::
A X E^T + E X A^T + B B^T = 0.
If trans is `True`, then it solves (if E is `None`)
.. math::
A^T X + X A + B^T B = 0
or
.. math::
A^T X E + E^T X A + B^T B = 0.
This uses the `pymess` package, in particular its `lyap` and
`lradi` methods.
Both methods can be used for large-scale problems.
The restrictions are:
- `lyap` needs access to all matrix data, i.e., it expects
:func:`~pymor.algorithms.to_matrix.to_matrix` to work for
A, E, and B,
- `lradi` needs access to the data of the operator B, i.e.,
it expects :func:`~pymor.algorithms.to_matrix.to_matrix`
to work for B.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The |Operator| B.
trans
If the dual equation needs to be solved.
options
The |solver_options| to use (see
:func:`lyap_solver_options`).
default_solver
The solver to use when no `options` are specified
(`'pymess'`, `'pymess_lyap'`, or `'pymess_lradi'`).
Returns
-------
Z
Low-rank factor of the Lyapunov equation solution,
|VectorArray| from `A.source`.
"""
_solve_lyap_check_args(A, E, B, trans)
options = _parse_options(options, lyap_solver_options(), default_solver, None, False)
if options['type'] == 'pymess':
if A.source.dim >= PYMESS_MIN_SPARSE_SIZE:
options = dict(options, type='pymess_lradi') # do not modify original dict!
else:
options = dict(options, type='pymess_lyap') # do not modify original dict!
if options['type'] == 'pymess_lyap':
A_mat = to_matrix(A, format='dense') if A.source.dim < PYMESS_MIN_SPARSE_SIZE else to_matrix(A)
if E is not None:
E_mat = to_matrix(E, format='dense') if A.source.dim < PYMESS_MIN_SPARSE_SIZE else to_matrix(E)
else:
E_mat = None
B_mat = to_matrix(B, format='dense')
if not trans:
Z = pymess.lyap(A_mat, E_mat, B_mat)
else:
if E is None:
Z = pymess.lyap(A_mat.T, None, B_mat.T)
else:
Z = pymess.lyap(A_mat.T, E_mat.T, B_mat.T)
elif options['type'] == 'pymess_lradi':
opts = options['opts']
if trans:
opts.type = pymess.MESS_OP_TRANSPOSE
else:
opts.type = pymess.MESS_OP_NONE
eqn = LyapunovEquation(opts, A, E, B)
Z, status = pymess.lradi(eqn, opts)
Z = A.source.from_numpy(np.array(Z).T)
return Z
def solve_lyap_lrcf(A, E, B, trans=False, options=None):
"""Compute an approximate low-rank solution of a Lyapunov equation.
See :func:`pymor.algorithms.lyapunov.solve_lyap_lrcf` for a
general description.
This function uses the low-rank ADI iteration as described in
Algorithm 4.3 in [PK16]_.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
trans
Whether the first |Operator| in the Lyapunov equation is
transposed.
options
The solver options to use (see
:func:`lyap_lrcf_solver_options`).
Returns
-------
Z
Low-rank Cholesky factor of the Lyapunov equation solution,
|VectorArray| from `A.source`.
"""
_solve_lyap_lrcf_check_args(A, E, B, trans)
options = _parse_options(options, lyap_lrcf_solver_options(), 'lradi', None, False)
logger = getLogger('pymor.algorithms.lradi.solve_lyap_lrcf')
shift_options = options['shift_options'][options['shifts']]
if shift_options['type'] == 'projection_shifts':
init_shifts = projection_shifts_init
iteration_shifts = projection_shifts
else:
raise ValueError('Unknown lradi shift strategy.')
if E is None:
E = IdentityOperator(A.source)
Z = A.source.empty(reserve=len(B) * options['maxiter'])
W = B.copy()
j = 0
j_shift = 0
shifts = init_shifts(A, E, W, shift_options)
res = np.linalg.norm(W.gramian(), ord=2)
init_res = res
Btol = res * options['tol']
while res > Btol and j < options['maxiter']:
if shifts[j_shift].imag == 0:
AaE = A + shifts[j_shift].real * E
if not trans:
V = AaE.apply_inverse(W)
W -= E.apply(V) * (2 * shifts[j_shift].real)
else:
V = AaE.apply_inverse_adjoint(W)
W -= E.apply_adjoint(V) * (2 * shifts[j_shift].real)
Z.append(V * np.sqrt(-2 * shifts[j_shift].real))
j += 1
else:
AaE = A + shifts[j_shift] * E
gs = -4 * shifts[j_shift].real
d = shifts[j_shift].real / shifts[j_shift].imag
if not trans:
V = AaE.apply_inverse(W)
W += E.apply(V.real + V.imag * d) * gs
else:
V = AaE.apply_inverse_adjoint(W).conj()
W += E.apply_adjoint(V.real + V.imag * d) * gs
g = np.sqrt(gs)
Z.append((V.real + V.imag * d) * g)
Z.append(V.imag * (g * np.sqrt(d**2 + 1)))
j += 2
j_shift += 1
res = np.linalg.norm(W.gramian(), ord=2)
logger.info(f'Relative residual at step {j}: {res/init_res:.5e}')
if j_shift >= shifts.size:
shifts = iteration_shifts(A, E, V, shifts)
j_shift = 0
if res > Btol:
logger.warning(f'Prescribed relative residual tolerance was not achieved '
f'({res/init_res:e} > {options["tol"]:e}) after ' f'{options["maxiter"]} ADI steps.')
return Z
def solve_ricc_lrcf(A, E, B, C, R=None, S=None, trans=False, options=None):
"""Compute an approximate low-rank solution of a Riccati equation.
See :func:`pymor.algorithms.riccati.solve_ricc_lrcf` for a general
description.
This function uses `scipy.linalg.solve_continuous_are`, which
is a dense solver.
Therefore, we assume all |Operators| and |VectorArrays| can be
converted to |NumPy arrays| using
:func:`~pymor.algorithms.to_matrix.to_matrix` and
:func:`~pymor.vectorarrays.interfaces.VectorArrayInterface.to_numpy`.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
C
The operator C as a |VectorArray| from `A.source`.
R
The operator R as a 2D |NumPy array| or `None`.
S
The operator S as a |VectorArray| from `A.source` or `None`.
trans
Whether the first |Operator| in the Riccati equation is
transposed.
options
The solver options to use (see :func:`ricc_lrcf_solver_options`).
Returns
-------
Z
Low-rank Cholesky factor of the Riccati equation solution,
|VectorArray| from `A.source`.
"""
_solve_ricc_check_args(A, E, B, C, R, S, trans)
options = _parse_options(options, ricc_lrcf_solver_options(), 'scipy', None, False)
if options['type'] != 'scipy':
raise ValueError(f"Unexpected Riccati equation solver ({options['type']}).")
A_source = A.source
A = to_matrix(A, format='dense')
E = to_matrix(E, format='dense') if E else None
B = B.to_numpy().T
C = C.to_numpy()
S = S.to_numpy().T if S else None
if R is None:
R = np.eye(C.shape[0] if not trans else B.shape[1])
if not trans:
if E is not None:
E = E.T
X = solve_continuous_are(A.T, C.T, B.dot(B.T), R, E, S)
else:
X = solve_continuous_are(A, B, C.T.dot(C), R, E, S)
return A_source.from_numpy(_chol(X).T)
def apply_inverse(op, V, options=None, least_squares=False, check_finite=True, default_solver='pyamg_solve'):
"""Solve linear equation system.
Applies the inverse of `op` to the vectors in `rhs` using PyAMG.
Parameters
----------
op
The linear, non-parametric |Operator| to invert.
rhs
|VectorArray| of right-hand sides for the equation system.
options
The |solver_options| to use (see :func:`solver_options`).
check_finite
Test if solution only containes finite values.
default_solver
Default solver to use (pyamg_solve, pyamg_rs, pyamg_sa).
Returns
-------
|VectorArray| of the solution vectors.
"""
assert V in op.range
if isinstance(op, NumpyMatrixOperator):
matrix = op._matrix
else:
from pymor.algorithms.to_matrix import to_matrix
matrix = to_matrix(op)
options = _parse_options(options, solver_options(), default_solver, None, least_squares)
V = V.data
promoted_type = np.promote_types(matrix.dtype, V.dtype)
R = np.empty((len(V), matrix.shape[1]), dtype=promoted_type)
if options['type'] == 'pyamg_solve':
if len(V) > 0:
V_iter = iter(enumerate(V))
R[0], ml = pyamg.solve(matrix, next(V_iter)[1],
tol=options['tol'],
maxiter=options['maxiter'],
return_solver=True)
for i, VV in V_iter:
R[i] = pyamg.solve(matrix, VV,
tol=options['tol'],
maxiter=options['maxiter'],
existing_solver=ml)
elif options['type'] == 'pyamg_rs':
ml = pyamg.ruge_stuben_solver(matrix,
strength=options['strength'],
CF=options['CF'],
presmoother=options['presmoother'],
postsmoother=options['postsmoother'],
max_levels=options['max_levels'],
max_coarse=options['max_coarse'],
coarse_solver=options['coarse_solver'])
for i, VV in enumerate(V):
R[i] = ml.solve(VV,
tol=options['tol'],
maxiter=options['maxiter'],
cycle=options['cycle'],
accel=options['accel'])
elif options['type'] == 'pyamg_sa':
ml = pyamg.smoothed_aggregation_solver(matrix,
symmetry=options['symmetry'],
strength=options['strength'],
aggregate=options['aggregate'],
smooth=options['smooth'],
presmoother=options['presmoother'],
postsmoother=options['postsmoother'],
improve_candidates=options['improve_candidates'],
max_levels=options['max_levels'],
max_coarse=options['max_coarse'],
diagonal_dominance=options['diagonal_dominance'])
for i, VV in enumerate(V):
R[i] = ml.solve(VV,
tol=options['tol'],
maxiter=options['maxiter'],
cycle=options['cycle'],
accel=options['accel'])
else:
raise ValueError('Unknown solver type')
if check_finite:
if not np.isfinite(np.sum(R)):
raise InversionError('Result contains non-finite values')
return op.source.from_data(R)
def solve_ricc_lrcf(A,
E,
B,
C,
R=None,
S=None,
trans=False,
options=None,
default_solver=None):
"""Compute an approximate low-rank solution of a Riccati equation.
See :func:`pymor.algorithms.riccati.solve_ricc_lrcf` for a
general description.
This function uses `pymess.dense_nm_gmpcare` and `pymess.lrnm`.
For both methods,
:meth:`~pymor.vectorarrays.interface.VectorArray.to_numpy`
and
:meth:`~pymor.vectorarrays.interface.VectorSpace.from_numpy`
need to be implemented for `A.source`.
Additionally, since `dense_nm_gmpcare` is a dense solver, it
expects :func:`~pymor.algorithms.to_matrix.to_matrix` to work
for A and E.
If the solver is not specified using the options or
default_solver arguments, `dense_nm_gmpcare` is used for small
problems (smaller than defined with
:func:`~pymor.algorithms.lyapunov.mat_eqn_sparse_min_size`) and
`lrnm` for large problems.
Parameters
----------
A
The non-parametric |Operator| A.
E
The non-parametric |Operator| E or `None`.
B
The operator B as a |VectorArray| from `A.source`.
C
The operator C as a |VectorArray| from `A.source`.
R
The operator R as a 2D |NumPy array| or `None`.
S
The operator S as a |VectorArray| from `A.source` or `None`.
trans
Whether the first |Operator| in the Riccati equation is
transposed.
options
The solver options to use (see
:func:`ricc_lrcf_solver_options`).
default_solver
Default solver to use (pymess_lrnm,
pymess_dense_nm_gmpcare).
If `None`, chose solver depending on dimension `A`.
Returns
-------
Z
Low-rank Cholesky factor of the Riccati equation solution,
|VectorArray| from `A.source`.
"""
_solve_ricc_check_args(A, E, B, C, R, S, trans)
if default_solver is None:
default_solver = 'pymess_lrnm' if A.source.dim >= mat_eqn_sparse_min_size(
) else 'pymess_dense_nm_gmpcare'
options = _parse_options(options, ricc_lrcf_solver_options(),
default_solver, None, False)
if options['type'] == 'pymess_dense_nm_gmpcare':
X = _call_pymess_dense_nm_gmpare(A,
E,
B,
C,
R,
S,
trans=trans,
options=options['opts'],
plus=False,
method_name='solve_ricc_lrcf')
Z = _chol(X)
elif options['type'] == 'pymess_lrnm':
if S is not None:
raise NotImplementedError
if R is not None:
import scipy.linalg as spla
Rc = spla.cholesky(R) # R = Rc^T * Rc
Rci = spla.solve_triangular(Rc, np.eye(
Rc.shape[0])) # R^{-1} = Rci * Rci^T
if not trans:
C = C.lincomb(Rci.T) # C <- Rci^T * C = (C^T * Rci)^T
else:
B = B.lincomb(Rci.T) # B <- B * Rci
opts = options['opts']
opts.type = pymess.MESS_OP_NONE if not trans else pymess.MESS_OP_TRANSPOSE
eqn = RiccatiEquation(opts, A, E, B, C)
Z, status = pymess.lrnm(eqn, opts)
relres = status.res2_norm / status.res2_0
if relres > opts.adi.res2_tol:
logger = getLogger('pymor.bindings.pymess.solve_ricc_lrcf')
logger.warning(
f'Desired relative residual tolerance was not achieved '
f'({relres:e} > {opts.adi.res2_tol:e}).')
else:
raise ValueError(
f'Unexpected Riccati equation solver ({options["type"]}).')
return A.source.from_numpy(Z.T)
def solve_lyap(A, E, B, trans=False, options=None):
"""Find a factor of the solution of a Lyapunov equation.
Returns factor :math:`Z` such that :math:`Z Z^T` is
approximately the solution :math:`X` of a Lyapunov equation (if
E is `None`).
.. math::
A X + X A^T + B B^T = 0
or generalized Lyapunov equation
.. math::
A X E^T + E X A^T + B B^T = 0.
If trans is `True`, then it solves (if E is `None`)
.. math::
A^T X + X A + B^T B = 0
or
.. math::
A^T X E + E^T X A + B^T B = 0.
This uses the `slycot` package, in particular its interfaces to
SLICOT functions `SB03MD` (for the standard Lyapunov equations)
and `SG03AD` (for the generalized Lyapunov equations).
These methods are only applicable to medium-sized dense
problems and need access to the matrix data of all operators.
Parameters
----------
A
The |Operator| A.
E
The |Operator| E or `None`.
B
The |Operator| B.
trans
If the dual equation needs to be solved.
options
The |solver_options| to use (see
:func:`lyap_solver_options`).
Returns
-------
Z
Low-rank factor of the Lyapunov equation solution, |VectorArray| from `A.source`.
"""
_solve_lyap_check_args(A, E, B, trans)
options = _parse_options(options, lyap_solver_options(), 'slycot', None, False)
assert options['type'] == 'slycot'
import slycot
A_mat = to_matrix(A, format='dense')
if E is not None:
E_mat = to_matrix(E, format='dense')
B_mat = to_matrix(B, format='dense')
n = A_mat.shape[0]
if not trans:
C = -B_mat.dot(B_mat.T)
trana = 'T'
else:
C = -B_mat.T.dot(B_mat)
trana = 'N'
dico = 'C'
if E is None:
U = np.zeros((n, n))
X, scale, _, _, _ = slycot.sb03md(n, C, A_mat, U, dico, trana=trana)
else:
job = 'B'
fact = 'N'
Q = np.zeros((n, n))
Z = np.zeros((n, n))
uplo = 'L'
X = C
_, _, _, _, X, scale, _, _, _, _, _ = slycot.sg03ad(dico, job, fact, trana, uplo, n, A_mat, E_mat,
Q, Z, X)
from pymor.bindings.scipy import chol
Z = chol(X, copy=False)
Z = A.source.from_numpy(np.array(Z).T)
return Z
