casadi 3.6.4__cp39-none-macosx_11_0_arm64.whl → 3.6.6__cp39-none-macosx_11_0_arm64.whl

casadi/include/include/alpaqa/accelerators/internal/limited-memory-qr.hpp

@@ -1,295 +0,0 @@
-#include <alpaqa/config/config.hpp>
-#include <alpaqa/util/ringbuffer.hpp>
-#include <Eigen/Jacobi>
-#include <type_traits>
-
-namespace alpaqa {
-
-/// Incremental QR factorization using modified Gram-Schmidt with
-/// reorthogonalization.
-///
-/// Computes A = QR while allowing efficient removal of the first
-/// column of A or adding new columns at the end of A.
-template <Config Conf = DefaultConfig>
-class LimitedMemoryQR {
-  public:
-    USING_ALPAQA_CONFIG(Conf);
-    LimitedMemoryQR() = default;
-
-    /// @param  n
-    ///         The size of the vectors, the number of rows of A.
-    /// @param  m
-    ///         The maximum number of columns of A.
-    ///
-    /// The maximum dimensions of Q are n×m and the maximum dimensions of R are
-    /// m×m.
-    LimitedMemoryQR(length_t n, length_t m) : Q(n, m), R(m, m) {}
-
-    length_t n() const { return Q.rows(); }
-    length_t m() const { return Q.cols(); }
-    length_t size() const { return n(); }
-    length_t history() const { return m(); }
-
-    /// Add the given column to the right.
-    template <class VecV>
-    void add_column(const VecV &v) {
-        assert(num_columns() < m());
-
-        auto q = Q.col(q_idx);
-        auto r = R.col(r_idx_end);
-
-        // Modified Gram-Schmidt to make q orthogonal to Q
-        q = v;
-        for (index_t i = 0; i < q_idx; ++i) {
-            real_t s = Q.col(i).dot(q);
-            r(i)     = s;
-            q -= s * Q.col(i);
-        }
-
-        // Compute the norms of orthogonalized q and original v
-        real_t norm_q = q.norm();
-        real_t norm_v = v.norm();
-
-        // If ‖q‖ is significantly smaller than ‖v‖, perform
-        // reorthogonalization
-        auto η = real_t(0.7);
-        while (norm_q < η * norm_v) {
-            ++reorth_count;
-            for (index_t i = 0; i < q_idx; ++i) {
-                real_t s = Q.col(i).dot(q);
-                r(i) += s;
-                q -= s * Q.col(i);
-            }
-            norm_v = norm_q;
-            norm_q = q.norm();
-        }
-
-        // Normalize q such that new matrix (Q q) remains orthogonal (i.e. has
-        // orthonormal columns)
-        r(q_idx) = norm_q;
-        q /= norm_q;
-        // Keep track of the minimum/maximum diagonal element of R
-        min_eig = std::min(min_eig, norm_q);
-        max_eig = std::max(max_eig, norm_q);
-
-        // Increment indices, add a column to Q and R.
-        ++q_idx;
-        r_idx_end = r_succ(r_idx_end);
-    }
-
-    /// Remove the leftmost column.
-    void remove_column() {
-        assert(num_columns() > 0);
-
-        // After removing the first column of the upper triangular matrix R,
-        // it becomes upper Hessenberg. Givens rotations are used to make it
-        // triangular again.
-        Eigen::JacobiRotation<real_t> G;
-        index_t r = 0;                   // row index of R
-        index_t c = r_succ(r_idx_start); // column index of R in storage
-        // Loop over the diagonal elements of R:
-        while (r < q_idx - 1) {
-            // Compute the Givens rotation that makes the subdiagonal element
-            // of column c of R zero.
-            G.makeGivens(R(r, c), R(r + 1, c), &R(r, c));
-            // Apply it to the remaining columns of R.
-            // Not the current column, because the diagonal element was updated
-            // by the makeGivens function, and the subdiagonal element doesn't
-            // have to be set to zero explicitly, it's implicit.
-            // Also not the previous columns, because they are already
-            // implicitly zero below the diagonal and this rotation wouldn't
-            // have any effect there.
-            // TODO: can this be sped up by applying it in two blocks instead
-            //       of column by column?
-            for (index_t cc = r_succ(c); cc != r_idx_end; cc = r_succ(cc))
-                R.col(cc).applyOnTheLeft(r, r + 1, G.adjoint());
-            // Apply the inverse of the Givens rotation to Q.
-            Q.block(0, 0, Q.rows(), q_idx).applyOnTheRight(r, r + 1, G);
-            // Keep track of the minimum/maximum diagonal element of R
-            min_eig = std::min(min_eig, R(r, c));
-            max_eig = std::max(max_eig, R(r, c));
-            // Advance indices to next diagonal element of R.
-            ++r;
-            c = r_succ(c);
-        }
-        // Remove rightmost column of Q, since it corresponds to the bottom row
-        // of R, which was set to zero by the Givens rotations
-        --q_idx;
-        // Remove the first column of R.
-        r_idx_start = r_succ(r_idx_start);
-    }
-
-    /// Solve the least squares problem Ax = b.
-    /// Do not divide by elements that are smaller in absolute value than @p tol.
-    template <class VecB, class VecX>
-    void solve_col(const VecB &b, VecX &x, real_t tol = 0) const {
-        // Iterate over the diagonal of R, starting at the bottom right,
-        // this is standard back substitution
-        // (recall that R is stored in a circular buffer, so R.col(i) is
-        // not the mathematical i-th column)
-        auto rev_bgn = ring_reverse_iter().begin();
-        auto rev_end = ring_reverse_iter().end();
-        auto fwd_end = ring_iter().end();
-        for (auto it_d = rev_bgn; it_d != rev_end; ++it_d) {
-            // Row/column index of diagonal element of R
-            auto [rR, cR] = *it_d;
-            // Don't divide by very small diagonal elements
-            if (std::abs(R(rR, cR)) < tol) {
-                x(rR) = real_t{0};
-                continue;
-            }
-            // (r is the zero-based mathematical index, c is the index in
-            // the circular buffer)
-            x(rR) = Q.col(rR).transpose() * b; // Compute rhs Qᵀb
-            // In the current row of R, iterate over the elements to the
-            // right of the diagonal
-            // Iterating from left to right seems to give better results
-            for (auto it_c = it_d.forwardit; it_c != fwd_end; ++it_c) {
-                auto [rX2, cR2] = *it_c;
-                x(rR) -= R(rR, cR2) * x(rX2);
-            }
-            x(rR) /= R(rR, cR); // Divide by diagonal element
-        }
-    }
-
-    /// Solve the least squares problem AX = B.
-    /// Do not divide by elements that are smaller in absolute value than @p tol.
-    template <class MatB, class MatX>
-    void solve(const MatB &B, MatX &X, real_t tol = 0) const {
-        assert(B.cols() <= X.cols());
-        assert(B.rows() >= Q.rows());
-        assert(X.rows() >= Eigen::Index(num_columns()));
-        // Each column of the right hand side is solved as an individual system
-        for (Eigen::Index cB = 0; cB < B.cols(); ++cB) {
-            auto b = B.col(cB);
-            auto x = X.col(cB);
-            solve_col(b, x, tol);
-        }
-    }
-
-    template <class Derived>
-    using solve_ret_t = std::conditional_t<
-        Eigen::internal::traits<Derived>::ColsAtCompileTime == 1, vec, mat>;
-
-    /// Solve the least squares problem AX = B.
-    template <class Derived>
-    solve_ret_t<Derived> solve(const Eigen::DenseBase<Derived> &B) {
-        solve_ret_t<Derived> X(m(), B.cols());
-        solve(B, X);
-        return X;
-    }
-
-    /// Get the full, raw storage for the orthogonal matrix Q.
-    const mat &get_raw_Q() const { return Q; }
-    /// Get the full, raw storage for the upper triangular matrix R.
-    /// The columns of this matrix are permuted because it's stored as a
-    /// circular buffer for efficiently appending columns to the end and
-    /// popping columns from the front.
-    const mat &get_raw_R() const { return R; }
-
-    /// Get the full storage for the upper triangular matrix R but with the
-    /// columns in the correct order.
-    /// @note   Meant for tests only, creates a permuted copy.
-    mat get_full_R() const {
-        if (r_idx_start == 0)
-            return R;
-        // Using a permutation matrix here isn't as efficient as rotating the
-        // matrix manually, but this function is only used in tests, so it
-        // shouldn't matter.
-        Eigen::PermutationMatrix<Eigen::Dynamic> P(R.cols());
-        P.setIdentity();
-        std::rotate(P.indices().data(), P.indices().data() + r_idx_start,
-                    P.indices().data() + P.size());
-        return R * P;
-    }
-    /// Get the matrix R such that Q times R is the original matrix.
-    /// @note   Meant for tests only, creates a permuted copy.
-    mat get_R() const {
-        return get_full_R()
-            .block(0, 0, q_idx, q_idx)
-            .template triangularView<Eigen::Upper>();
-    }
-    /// Get the matrix Q such that Q times R is the original matrix.
-    /// @note   Meant for tests only, creates a copy.
-    mat get_Q() const { return Q.block(0, 0, n(), q_idx); }
-
-    /// Multiply the matrix R by a scalar.
-    void scale_R(real_t scal) {
-        for (auto [i, r_idx] : ring_iter())
-            R.col(r_idx).topRows(i + 1) *= scal;
-        min_eig *= scal;
-        max_eig *= scal;
-    }
-
-    /// Get the number of MGS reorthogonalizations.
-    unsigned long get_reorth_count() const { return reorth_count; }
-    /// Reset the number of MGS reorthogonalizations.
-    void clear_reorth_count() { reorth_count = 0; }
-
-    /// Get the minimum eigenvalue of R.
-    real_t get_min_eig() const { return min_eig; }
-    /// Get the maximum eigenvalue of R.
-    real_t get_max_eig() const { return max_eig; }
-
-    /// Reset all indices, clearing the Q and R matrices.
-    void reset() {
-        q_idx        = 0;
-        r_idx_start  = 0;
-        r_idx_end    = 0;
-        reorth_count = 0;
-        min_eig      = +inf<config_t>;
-        max_eig      = -inf<config_t>;
-    }
-
-    /// Re-allocate storage for a problem with a different size. Causes
-    /// a @ref reset.
-    void resize(length_t n, length_t m) {
-        Q.resize(n, m);
-        R.resize(m, m);
-        reset();
-    }
-
-    /// Get the number of columns that are currently stored.
-    length_t num_columns() const { return q_idx; }
-    /// Get the head index of the circular buffer (points to the oldest
-    /// element).
-    index_t ring_head() const { return r_idx_start; }
-    /// Get the tail index of the circular buffer (points to one past the most
-    /// recent element).
-    index_t ring_tail() const { return r_idx_end; }
-    /// Get the next index in the circular buffer.
-    index_t ring_next(index_t i) const { return r_succ(i); }
-    /// Get the previous index in the circular buffer.
-    index_t ring_prev(index_t i) const { return r_pred(i); }
-    /// Get the number of columns currently stored in the buffer.
-    length_t current_history() const { return q_idx; }
-
-    /// Get iterators in the circular buffer.
-    CircularRange<index_t> ring_iter() const {
-        return {q_idx, r_idx_start, r_idx_end, m()};
-    }
-    /// Get reverse iterators in the circular buffer.
-    ReverseCircularRange<index_t> ring_reverse_iter() const {
-        return ring_iter();
-    }
-
-  private:
-    mat Q; ///< Storage for orthogonal factor Q.
-    mat R; ///< Storage for upper triangular factor R.
-
-    index_t q_idx       = 0; ///< Number of columns of Q being stored.
-    index_t r_idx_start = 0; ///< Index of the first column of R.
-    index_t r_idx_end   = 0; ///< Index of the one-past-last column of R.
-
-    unsigned long reorth_count = 0; ///< Number of MGS reorthogonalizations.
-
-    real_t min_eig = +inf<config_t>; ///< Minimum eigenvalue of R.
-    real_t max_eig = -inf<config_t>; ///< Maximum eigenvalue of R.
-
-    /// Get the next index in the circular storage for R.
-    index_t r_succ(index_t i) const { return i + 1 < m() ? i + 1 : 0; }
-    /// Get the previous index in the circular storage for R.
-    index_t r_pred(index_t i) const { return i == 0 ? m() - 1 : i - 1; }
-};
-
-} // namespace alpaqa

casadi/include/include/alpaqa/accelerators/lbfgs.hpp

@@ -1,244 +0,0 @@
-#pragma once
-
-#include <alpaqa/config/config.hpp>
-#include <alpaqa/export.hpp>
-
-#include <cmath>
-#include <limits>
-#include <string>
-#include <utility>
-#include <vector>
-
-namespace alpaqa {
-
-/// Cautious BFGS update.
-/// @see @ref LBFGSParams::cbfgs
-template <Config Conf = DefaultConfig>
-struct CBFGSParams {
-    USING_ALPAQA_CONFIG(Conf);
-    real_t α = 1;
-    real_t ϵ = 0; ///< Set to zero to disable CBFGS check.
-    explicit operator bool() const { return ϵ > 0; }
-};
-
-/// Which method to use to select the L-BFGS step size.
-enum class LBFGSStepSize {
-    /// Initial inverse Hessian approximation is set to
-    /// @f$ H_0 = \gamma I @f$.
-    BasedOnExternalStepSize = 0,
-    /// Initial inverse Hessian approximation is set to
-    /// @f$ H_0 = \frac{s^\top y}{y^\top y} I @f$.
-    BasedOnCurvature = 1,
-    BasedOnGradientStepSize
-    [[deprecated("use BasedOnExternalStepSize instead")]] =
-        BasedOnExternalStepSize,
-};
-
-/// Parameters for the @ref LBFGS class.
-template <Config Conf = DefaultConfig>
-struct LBFGSParams {
-    USING_ALPAQA_CONFIG(Conf);
-
-    /// Length of the history to keep.
-    length_t memory = 10;
-    /// Reject update if @f$ y^\top s \le \text{min_div_fac} \cdot s^\top s @f$.
-    real_t min_div_fac = std::numeric_limits<real_t>::epsilon();
-    /// Reject update if @f$ s^\top s \le \text{min_abs_s} @f$.
-    real_t min_abs_s =
-        std::pow(std::numeric_limits<real_t>::epsilon(), real_t(2));
-    /// Parameters in the cautious BFGS update condition
-    /// @f[ \frac{y^\top s}{s^\top s} \ge \epsilon \| g \|^\alpha @f]
-    /// @see https://epubs.siam.org/doi/10.1137/S1052623499354242
-    CBFGSParams<config_t> cbfgs = {};
-    /// If set to true, the inverse Hessian estimate should remain definite,
-    /// i.e. a check is performed that rejects the update if
-    /// @f$ y^\top s \le \text{min_div_fac} \cdot s^\top s @f$.
-    /// If set to false, just try to prevent a singular Hessian by rejecting the
-    /// update if
-    /// @f$ \left| y^\top s \right| \le \text{min_div_fac} \cdot s^\top s @f$.
-    bool force_pos_def = true;
-    /// @see LBFGSStepSize
-    LBFGSStepSize stepsize = LBFGSStepSize::BasedOnCurvature;
-};
-
-/// Layout:
-/// ~~~
-///       ┌───── 2 m ─────┐
-///     ┌ ┌───┬───┬───┬───┐
-///     │ │   │   │   │   │
-///     │ │ s │ y │ s │ y │
-/// n+1 │ │   │   │   │   │
-///     │ ├───┼───┼───┼───┤
-///     │ │ ρ │ α │ ρ │ α │
-///     └ └───┴───┴───┴───┘
-/// ~~~
-template <Config Conf = DefaultConfig>
-struct LBFGSStorage {
-    USING_ALPAQA_CONFIG(Conf);
-
-    /// Re-allocate storage for a problem with a different size.
-    void resize(length_t n, length_t history);
-
-    /// Get the size of the s and y vectors in the buffer.
-    length_t n() const { return sto.rows() - 1; }
-    /// Get the number of previous vectors s and y stored in the buffer.
-    length_t history() const { return sto.cols() / 2; }
-
-    auto s(index_t i) { return sto.col(2 * i).topRows(n()); }
-    auto s(index_t i) const {
-        return std::as_const(sto).col(2 * i).topRows(n());
-    }
-    auto y(index_t i) { return sto.col(2 * i + 1).topRows(n()); }
-    auto y(index_t i) const {
-        return std::as_const(sto).col(2 * i + 1).topRows(n());
-    }
-    real_t &ρ(index_t i) { return sto.coeffRef(n(), 2 * i); }
-    real_t &ρ(index_t i) const { return sto.coeffRef(n(), 2 * i); }
-    real_t &α(index_t i) { return sto.coeffRef(n(), 2 * i + 1); }
-    real_t &α(index_t i) const { return sto.coeffRef(n(), 2 * i + 1); }
-
-    using storage_t = mat;
-    static_assert(!storage_t::IsRowMajor);
-    mutable storage_t sto;
-};
-
-/// Limited memory Broyden–Fletcher–Goldfarb–Shanno (L-BFGS) algorithm
-/// @ingroup grp_Accelerators
-template <Config Conf = DefaultConfig>
-class ALPAQA_EXPORT LBFGS {
-  public:
-    USING_ALPAQA_CONFIG(Conf);
-
-    using Params = LBFGSParams<config_t>;
-
-    /// The sign of the vectors @f$ p @f$ passed to the @ref update method.
-    enum class Sign {
-        Positive, ///< @f$ p \sim \nabla \psi(x) @f$
-        Negative, ///< @f$ p \sim -\nabla \psi(x) @f$
-    };
-
-    LBFGS() = default;
-    LBFGS(Params params) : params(params) {}
-    LBFGS(Params params, length_t n) : params(params) { resize(n); }
-
-    /// Check if the new vectors s and y allow for a valid BFGS update that
-    /// preserves the positive definiteness of the Hessian approximation.
-    static bool update_valid(const Params &params, real_t yᵀs, real_t sᵀs,
-                             real_t pᵀp);
-
-    /// Update the inverse Hessian approximation using the new vectors
-    /// sₖ = xₙₑₓₜ - xₖ and yₖ = pₙₑₓₜ - pₖ.
-    bool update_sy(crvec s, crvec y, real_t pₙₑₓₜᵀpₙₑₓₜ, bool forced = false);
-    /// @see @ref update_sy
-    bool update_sy_impl(const auto &s, const auto &y, real_t pₙₑₓₜᵀpₙₑₓₜ,
-                        bool forced = false);
-
-    /// Update the inverse Hessian approximation using the new vectors xₙₑₓₜ
-    /// and pₙₑₓₜ.
-    bool update(crvec xₖ, crvec xₙₑₓₜ, crvec pₖ, crvec pₙₑₓₜ,
-                Sign sign = Sign::Positive, bool forced = false);
-
-    /// Apply the inverse Hessian approximation to the given vector q.
-    /// Initial inverse Hessian approximation is set to @f$ H_0 = \gamma I @f$.
-    /// If @p γ is negative, @f$ H_0 = \frac{s^\top y}{y^\top y} I @f$.
-    bool apply(rvec q, real_t γ = -1) const;
-
-    /// Apply the inverse Hessian approximation to the given vector q, applying
-    /// only the columns and rows of the Hessian in the index set J.
-    bool apply_masked(rvec q, real_t γ, crindexvec J) const;
-    /// @copydoc apply_masked(rvec, real_t, crindexvec) const
-    bool apply_masked(rvec q, real_t γ, const std::vector<index_t> &J) const;
-    /// @copydoc apply_masked(rvec, real_t, crindexvec) const
-    bool apply_masked_impl(rvec q, real_t γ, const auto &J) const;
-
-    /// Throw away the approximation and all previous vectors s and y.
-    void reset();
-    /// Re-allocate storage for a problem with a different size. Causes
-    /// a @ref reset.
-    void resize(length_t n);
-
-    /// Scale the stored y vectors by the given factor.
-    void scale_y(real_t factor);
-
-    /// Get a string identifier for this accelerator.
-    std::string get_name() const {
-        return "LBFGS<" + std::string(config_t::get_name()) + '>';
-    }
-    /// Get the parameters.
-    const Params &get_params() const { return params; }
-
-    /// Get the size of the s and y vectors in the buffer.
-    length_t n() const { return sto.n(); }
-    /// Get the number of previous vectors s and y stored in the buffer.
-    length_t history() const { return sto.history(); }
-    /// Get the next index in the circular buffer of previous s and y vectors.
-    index_t succ(index_t i) const { return i + 1 < history() ? i + 1 : 0; }
-    /// Get the previous index in the circular buffer of s and y vectors.
-    index_t pred(index_t i) const { return i > 0 ? i - 1 : history() - 1; }
-    /// Get the number of previous s and y vectors currently stored in the
-    /// buffer.
-    length_t current_history() const { return full ? history() : idx; }
-
-    auto s(index_t i) { return sto.s(i); }
-    auto s(index_t i) const { return sto.s(i); }
-    auto y(index_t i) { return sto.y(i); }
-    auto y(index_t i) const { return sto.y(i); }
-    real_t &ρ(index_t i) { return sto.ρ(i); }
-    real_t &ρ(index_t i) const { return sto.ρ(i); }
-    real_t &α(index_t i) { return sto.α(i); }
-    real_t &α(index_t i) const { return sto.α(i); }
-
-    /// Iterate over the indices in the history buffer, oldest first.
-    template <class F>
-    void foreach_fwd(const F &fun) const {
-        if (full)
-            for (index_t i = idx; i < history(); ++i)
-                fun(i);
-        if (idx)
-            for (index_t i = 0; i < idx; ++i)
-                fun(i);
-    }
-
-    /// Iterate over the indices in the history buffer, newest first.
-    template <class F>
-    void foreach_rev(const F &fun) const {
-        if (idx)
-            for (index_t i = idx; i-- > 0;)
-                fun(i);
-        if (full)
-            for (index_t i = history(); i-- > idx;)
-                fun(i);
-    }
-
-  private:
-    LBFGSStorage<config_t> sto;
-    index_t idx = 0;
-    bool full   = false;
-    Params params;
-};
-
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, CBFGSParams, DefaultConfig);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, CBFGSParams, EigenConfigf);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, CBFGSParams, EigenConfigd);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, CBFGSParams, EigenConfigl);
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, CBFGSParams, EigenConfigq);
-#endif
-
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, LBFGSParams, DefaultConfig);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, LBFGSParams, EigenConfigf);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, LBFGSParams, EigenConfigd);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, LBFGSParams, EigenConfigl);
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, LBFGSParams, EigenConfigq);
-#endif
-
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, LBFGS, DefaultConfig);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, LBFGS, EigenConfigf);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, LBFGS, EigenConfigd);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, LBFGS, EigenConfigl);
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, LBFGS, EigenConfigq);
-#endif
-
-} // namespace alpaqa

casadi/include/include/alpaqa/accelerators/steihaugcg.hpp

@@ -1,143 +0,0 @@
-#pragma once
-
-#include <alpaqa/config/config.hpp>
-#include <alpaqa/util/alloc-check.hpp>
-
-namespace alpaqa {
-
-template <Config Conf>
-struct SteihaugCGParams {
-    USING_ALPAQA_CONFIG(Conf);
-    real_t tol_scale       = 1;
-    real_t tol_scale_root  = real_t(0.5);
-    real_t tol_max         = inf<config_t>;
-    real_t max_iter_factor = 1;
-};
-
-/// Steihaug conjugate gradients procedure based on
-/// https://github.com/scipy/scipy/blob/583e70a50573169fc352b5dc6d94588a97c7389a/scipy/optimize/_trustregion_ncg.py#L44
-template <Config Conf>
-struct SteihaugCG {
-    USING_ALPAQA_CONFIG(Conf);
-
-    using Params = SteihaugCGParams<config_t>;
-    Params params;
-
-    SteihaugCG() = default;
-    SteihaugCG(const Params &params) : params{params} {}
-
-    mutable vec z, r, d, Bd, work_eval;
-
-    void resize(length_t n) {
-        z.resize(n);
-        r.resize(n);
-        d.resize(n);
-        Bd.resize(n);
-        work_eval.resize(n);
-    }
-
-    template <class HessFun>
-    real_t solve(const auto &grad, const HessFun &hess_prod,
-                 real_t trust_radius, rvec step) const {
-        length_t n = grad.size();
-        // get the norm of jacobian and define the origin
-        auto v = [n](auto &v) { return v.topRows(n); };
-        auto z = v(this->z), r = v(this->r), d = v(this->d), Bd = v(this->Bd);
-        auto g = v(grad);
-        auto s = v(step);
-        // init the state for the first iteration
-        z.setZero();
-        r               = g;
-        d               = -r;
-        real_t r_sq     = r.squaredNorm();
-        real_t grad_mag = g.norm();
-
-        // define a default tolerance
-        real_t tolerance =
-            std::fmin(params.tol_max, params.tol_scale * grad_mag *
-                                          std::fmin(params.tol_scale_root,
-                                                    std::sqrt(grad_mag)));
-
-        // Workspaces and function evaluation
-        auto eval = [&](crvec p) {
-            hess_prod(p, work_eval);
-            return p.dot(g) + real_t(0.5) * p.dot(v(work_eval));
-        };
-
-        // Search for the min of the approximation of the objective function.
-        index_t i           = 0;
-        const auto max_iter = static_cast<index_t>(
-            std::round(static_cast<real_t>(n) * params.max_iter_factor));
-        while (true) {
-            // do an iteration
-            hess_prod(d, Bd);
-            real_t dBd = d.dot(Bd);
-            if (dBd <= 0) {
-                // Look at the two boundary points.
-                // Find both values of t to get the boundary points such that
-                // ||z + t d|| == trust_radius
-                // and then choose the one with the predicted min value.
-                auto [ta, tb] =
-                    get_boundaries_intersections(z, d, trust_radius);
-                auto &pa   = r; // Reuse storage
-                auto &pb   = d; // Reuse storage
-                pa         = z + ta * d;
-                pb         = z + tb * d;
-                real_t q_a = eval(pa), q_b = eval(pb);
-                real_t q_min = std::fmin(q_a, q_b);
-                if (q_a == q_min) {
-                    s = pa;
-                    return q_a;
-                } else {
-                    s = pb;
-                    return q_b;
-                }
-            }
-
-            real_t alpha = r_sq / dBd;
-            s            = z + alpha * d;
-            if (s.norm() >= trust_radius) {
-                // Find t >= 0 to get the boundary point such that
-                // ||z + t d|| == trust_radius
-                auto [ta, tb] =
-                    get_boundaries_intersections(z, d, trust_radius);
-                s = z + tb * d;
-                return eval(s);
-            }
-            r += alpha * Bd;
-            real_t r_next_sq = r.squaredNorm();
-            if (std::sqrt(r_next_sq) < tolerance || i > max_iter)
-                return eval(s);
-            real_t beta_next = r_next_sq / r_sq;
-            r_sq             = r_next_sq;
-            d                = beta_next * d - r;
-            z                = s;
-            ++i;
-        }
-    }
-
-    /// Solve the scalar quadratic equation ||z + t d|| == trust_radius.
-    /// This is like a line-sphere intersection.
-    /// Return the two values of t, sorted from low to high.
-    static auto get_boundaries_intersections(crvec z, crvec d,
-                                             real_t trust_radius) {
-        real_t a = d.squaredNorm();
-        real_t b = 2 * z.dot(d);
-        real_t c = z.squaredNorm() - trust_radius * trust_radius;
-        real_t sqrt_discriminant = std::sqrt(b * b - 4 * a * c);
-
-        // The following calculation is mathematically
-        // equivalent to:
-        // ta = (-b - sqrt_discriminant) / (2*a)
-        // tb = (-b + sqrt_discriminant) / (2*a)
-        // but produce smaller round off errors.
-        // Look at Matrix Computation p.97
-        // for a better justification.
-        real_t aux = b + std::copysign(sqrt_discriminant, b);
-        real_t ta  = -aux / (2 * a);
-        real_t tb  = -2 * c / aux;
-        return std::make_tuple(std::fmin(ta, tb), std::fmax(ta, tb));
-    }
-};
-
-} // namespace alpaqa

casadi/include/include/alpaqa/alpaqa.hpp

@@ -1,3 +0,0 @@
-#pragma once
-
-#include <alpaqa/panoc-alm.hpp>