pd_ipm_trace.hpp

Go to the documentation of this file.

/*
 * Copyright © 2025-2026 Akreon LLC
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <type_traits>
 
#include "akreon/convex/solver_config.hpp"
#include "akreon/convex/canonical_trace.hpp"
#include "akreon/linalg/linalg.hpp"
 
namespace convex {
 
template <linalg::Field T>
struct ConeStepTrace {
  T mu{};          
  T rhs_c_norm{};  
  T pz_rhs_norm{}; 
  bool active{};   
};
 
template <linalg::Field T, std::size_t NumCones>
struct PdIpmStepTrace {
  constexpr void reset() { *this = {}; }
 
  constexpr auto& cone(std::size_t idx) {
    AK_ASSERT(idx < NumCones);
    return cones[idx];
  }
  constexpr const auto& cone(std::size_t idx) const {
    AK_ASSERT(idx < NumCones);
    return cones[idx];
  }
 
  std::array<ConeStepTrace<T>, NumCones> cones{}; 
};
 
template <linalg::Field T, std::size_t NumCones>
struct PdIpmIterTrace {
 
  constexpr void reset() { *this = {}; }
 
  T mu{};       
  T alpha_x{};  
  T alpha_y{};  
  T rd_norm{};  
  T rp_norm{};  
  T req_norm{}; 
  T pz_norm{};  
  T pnu_norm{}; 
  T px_norm{};  
  T py_norm{};  
 
  PdIpmStepTrace<T, NumCones> predictor{}; 
  PdIpmStepTrace<T, NumCones> corrector{}; 
 
  config::SolverResult tag{};     
  linalg::NumericalEvent event{}; 
  bool stalled{};                 
};
 
template <linalg::Field T, std::size_t NumCones>
struct PdIpmTrace {
  constexpr void reset() { *this = {}; }
  static constexpr std::size_t num_cones = NumCones;
 
  constexpr bool full() const { return num_iters >= PD_IPM_STEPS; }
 
  constexpr std::size_t size() const { return num_iters; }
 
  constexpr auto& iter(std::size_t k) { return iters[k]; }
  constexpr const auto& iter(std::size_t k) const { return iters[k]; }
  constexpr auto& operator[](std::size_t k) { return iters[k]; }
  constexpr const auto& operator[](std::size_t k) const { return iters[k]; }
 
  constexpr auto& current() {
    return iters[(num_iters < PD_IPM_STEPS) ? num_iters : (PD_IPM_STEPS - 1)];
  }
 
  constexpr const auto& current() const {
    return iters[(num_iters < PD_IPM_STEPS) ? num_iters : (PD_IPM_STEPS - 1)];
  }
 
  constexpr bool commit_iter() {
    if (num_iters >= PD_IPM_STEPS) return false;
    ++num_iters;
    return true;
  }
 
  std::array<PdIpmIterTrace<T, NumCones>, PD_IPM_STEPS>
      iters{};             
  std::size_t num_iters{}; 
};
 
struct EmptyPdIpmSnapshot {};
 
template <linalg::Field T, std::size_t MaxConeDim>
struct PdIpmConeSnapshot {
  std::array<T, MaxConeDim> xk{};    
  std::array<T, MaxConeDim> yk{};    
  std::array<T, MaxConeDim> rhs_c{}; 
  std::array<T, MaxConeDim> px{};    
  std::array<T, MaxConeDim> py{};    
};
 
template <linalg::Field T, std::size_t VarDim, std::size_t EqDim>
struct PdIpmGlobalStepSnapshot {
  std::array<T, VarDim> pz{}; 
  std::array<T, EqDim> pnu{}; 
};
 
template <linalg::Field T, std::size_t NumCones, std::size_t MaxConeDim,
          std::size_t VarDim, std::size_t EqDim>
struct PdIpmFullIterSnapshot {
  std::array<PdIpmConeSnapshot<T, MaxConeDim>, NumCones>
      predictor_cones{}; 
  std::array<PdIpmConeSnapshot<T, MaxConeDim>, NumCones>
      corrector_cones{}; 
  PdIpmGlobalStepSnapshot<T, VarDim, EqDim>
      predictor_global{}; 
  PdIpmGlobalStepSnapshot<T, VarDim, EqDim>
      corrector_global{}; 
};
 
template <bool Enable, linalg::Field T, std::size_t NumCones,
          std::size_t MaxConeDim, std::size_t VarDim, std::size_t EqDim>
using PdIpmSnapshotStorage = std::conditional_t<
    Enable, PdIpmFullIterSnapshot<T, NumCones, MaxConeDim, VarDim, EqDim>,
    EmptyPdIpmSnapshot>;
 
template <linalg::Field T, typename CanonicalTraceT>
using PdIpmTraceForCanonicalTrace =
    PdIpmTrace<T, canonical_trace_num_cones_v<CanonicalTraceT>>;
 
} // namespace convex