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_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 `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`.
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(), 'scipy',
None, False)
if options['type'] != 'scipy':
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_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 `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 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(), 'scipy', None, False)
if options['type'] != 'scipy':
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, 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 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)
