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_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_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_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_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_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 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(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_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)