cone_traits.hpp

Go to the documentation of this file.

/*
 * Copyright © 2025-2026 Akreon LLC
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include <tuple>
 
#include "akreon/linalg/affine/affine_traits.hpp"
 
namespace conic {
 
enum struct ConeType : uint8_t { SYMMETRIC = 0, ASYMMETRIC };
 
template <linalg::VectorContainer Vec, typename Derived, ConeType Type>
struct Cone;
 
template <linalg::VectorContainer Vec>
struct NonnegOrthantCone;
 
template <linalg::VectorContainer Vec>
struct SecondOrderCone;
 
template <linalg::VectorContainer Vec, std::size_t N>
struct PositiveSemidefiniteCone;
 
template <linalg::VectorContainer Vec>
struct ExpCone;
 
template <linalg::VectorContainer Vec>
struct PowerCone;
 
template <typename Cone>
struct cone_traits;
 
template <linalg::VectorContainer Vec>
struct cone_traits<NonnegOrthantCone<Vec>> : std::false_type {
  using SlackT = Vec;
  using T = linalg::vector_element_t<Vec>;
  static constexpr ConeType CT = ConeType::SYMMETRIC;
  static constexpr std::size_t N = linalg::vector_dim_v<Vec>;
};
 
template <linalg::VectorContainer Vec>
struct cone_traits<SecondOrderCone<Vec>> : std::false_type {
  using SlackT = Vec;
  using T = linalg::vector_element_t<Vec>;
  static constexpr ConeType CT = ConeType::SYMMETRIC;
  static constexpr std::size_t N = linalg::vector_dim_v<Vec>;
};
 
template <linalg::VectorContainer Vec, std::size_t Dim>
struct cone_traits<PositiveSemidefiniteCone<Vec, Dim>> : std::false_type {
  using SlackT = Vec;
  using T = linalg::vector_element_t<Vec>;
  static constexpr ConeType CT = ConeType::SYMMETRIC;
  static constexpr std::size_t N = linalg::vector_dim_v<Vec>;
};
 
template <linalg::VectorContainer Vec>
struct cone_traits<ExpCone<Vec>> : std::false_type {
  using SlackT = Vec;
  using T = linalg::vector_element_t<Vec>;
  static constexpr ConeType CT = ConeType::ASYMMETRIC;
  static constexpr std::size_t N = linalg::vector_dim_v<Vec>;
};
 
template <linalg::VectorContainer Vec>
struct cone_traits<PowerCone<Vec>> : std::false_type {
  using SlackT = Vec;
  using T = linalg::vector_element_t<Vec>;
  static constexpr ConeType CT = ConeType::ASYMMETRIC;
  static constexpr std::size_t N = linalg::vector_dim_v<Vec>;
};
 
template <class Cone>
using cone_scalar_t = typename cone_traits<linalg::remove_cvref_t<Cone>>::T;
 
template <class Cone>
using cone_slack_t = typename cone_traits<linalg::remove_cvref_t<Cone>>::SlackT;
 
template <class Cone>
inline constexpr bool is_cone_symmetric_v =
    cone_traits<linalg::remove_cvref_t<Cone>>::CT == ConeType::SYMMETRIC;
 
template <class Cone>
inline constexpr std::size_t cone_dim_t =
    cone_traits<linalg::remove_cvref_t<Cone>>::N;
 
template <typename ConeTuple>
struct cone_tuple_traits;
 
template <typename... Cs>
struct cone_tuple_traits<std::tuple<Cs...>> {
  static constexpr std::size_t NumCones = sizeof...(Cs);
  static constexpr std::size_t LocalConeDim =
      (std::size_t{0} + ... + cone_dim_t<Cs>);
};
 
template <typename ConeTuple>
inline constexpr std::size_t cone_tuple_num_cones_v =
    cone_tuple_traits<linalg::remove_cvref_t<ConeTuple>>::NumCones;
 
template <typename ConeTuple>
inline constexpr std::size_t cone_tuple_local_cone_dim_v =
    cone_tuple_traits<linalg::remove_cvref_t<ConeTuple>>::LocalConeDim;
 
template <typename ConeTuple>
inline constexpr std::size_t cone_tuple_dim_v =
    cone_tuple_local_cone_dim_v<ConeTuple>;
 
template <affine::AffineMapLike Map, typename... Cs>
struct ConeBlock;
 
template <typename ConeBlock>
struct cone_block_traits;
 
template <affine::AffineMapLike Map, typename... Cs>
struct cone_block_traits<ConeBlock<Map, Cs...>> {
  using FMap = Map;
  using MapT = affine::affine_mat_t<Map>;
  using Cones = std::tuple<Cs...>;
 
  static constexpr std::size_t NumCones = sizeof...(Cs);
  static constexpr std::size_t LocalConeDim =
      cone_tuple_local_cone_dim_v<Cones>;
  static constexpr std::size_t MapRows = linalg::mat_rows_v<MapT>;
  static constexpr std::size_t MapCols = linalg::mat_cols_v<MapT>;
};
 
template <typename CB>
using cone_block_map_t =
    typename cone_block_traits<linalg::remove_cvref_t<CB>>::FMap;
 
template <typename CB>
inline constexpr std::size_t cone_block_num_cones_v =
    cone_block_traits<linalg::remove_cvref_t<CB>>::NumCones;
 
template <typename CB>
inline constexpr std::size_t cone_block_local_cone_dim_v =
    cone_block_traits<linalg::remove_cvref_t<CB>>::LocalConeDim;
 
template <typename CB>
inline constexpr std::size_t cone_block_cone_dim_v =
    cone_block_local_cone_dim_v<CB>;
 
template <typename CB>
inline constexpr std::size_t cone_block_map_rows_v =
    cone_block_traits<linalg::remove_cvref_t<CB>>::MapRows;
 
template <typename CB>
inline constexpr std::size_t cone_block_map_cols_v =
    cone_block_traits<linalg::remove_cvref_t<CB>>::MapCols;
 
template <class Cblk>
concept ConeBlockLike = requires(const Cblk& cblk) {
  { cblk.map };
  { cblk.cones };
};
 
template <typename Builder>
concept BuilderLike = requires(const Builder& builder) {
  { builder.coord_map };
  { builder.cb };
  { builder.eq_map };
};
 
template <linalg::RnSpace DecVarDom, affine::AffineMapLike CoordMap,
          conic::ConeBlockLike CB, affine::AffineMapLike EqMap,
          typename CanonicalTrace>
struct CanonicalFormBuilder;
 
template <typename Builder>
struct builder_traits;
 
template <linalg::RnSpace DecVarDom, affine::AffineMapLike CoordMap,
          conic::ConeBlockLike CB, affine::AffineMapLike EqMap,
          typename CanonicalTrace>
struct builder_traits<
    CanonicalFormBuilder<DecVarDom, CoordMap, CB, EqMap, CanonicalTrace>> {
  using Dom = DecVarDom;
  using Map = CoordMap;
  using CoordinateMap = CoordMap;
  using ConeBlock = CB;
  using EqualityMap = EqMap;
  using CanonicalTraceT = CanonicalTrace;
 
  using CoordMapT = affine::affine_mat_t<CoordMap>;
  using EqMapT = affine::affine_mat_t<EqMap>;
 
  static constexpr std::size_t DecDim = linalg::space_dim_v<DecVarDom>;
  static constexpr std::size_t CoordRows = linalg::mat_rows_v<CoordMapT>;
  static constexpr std::size_t CoordCols = linalg::mat_cols_v<CoordMapT>;
  static constexpr std::size_t CoordAuxDim =
      CoordCols > DecDim ? CoordCols - DecDim : 0;
 
  static constexpr std::size_t ConeRows = cone_block_map_rows_v<CB>;
  static constexpr std::size_t ConeCols = cone_block_map_cols_v<CB>;
  static constexpr std::size_t ConeAuxDim =
      ConeCols > DecDim ? ConeCols - DecDim : 0;
  static constexpr std::size_t ConeCount = cone_block_num_cones_v<CB>;
  static constexpr std::size_t LocalConeDim = cone_block_local_cone_dim_v<CB>;
 
  static constexpr std::size_t EqRows = linalg::mat_rows_v<EqMapT>;
  static constexpr std::size_t EqCols = linalg::mat_cols_v<EqMapT>;
  static constexpr std::size_t EqAuxDim = EqCols > DecDim ? EqCols - DecDim : 0;
 
  static constexpr std::size_t FullDim = ConeCols > EqCols ? ConeCols : EqCols;
};
 
template <typename Builder>
using builder_dom_t =
    typename builder_traits<linalg::remove_cvref_t<Builder>>::Dom;
 
template <typename Builder>
using builder_map_t =
    typename builder_traits<linalg::remove_cvref_t<Builder>>::Map;
 
template <typename Builder>
using builder_cb_t =
    typename builder_traits<linalg::remove_cvref_t<Builder>>::ConeBlock;
 
template <typename Builder>
using builder_eq_t =
    typename builder_traits<linalg::remove_cvref_t<Builder>>::EqualityMap;
 
template <typename Builder>
using builder_canonical_trace_t =
    typename builder_traits<linalg::remove_cvref_t<Builder>>::CanonicalTraceT;
 
template <typename Builder>
inline constexpr std::size_t builder_dec_dim_v =
    builder_traits<linalg::remove_cvref_t<Builder>>::DecDim;
 
template <typename Builder>
inline constexpr std::size_t builder_coord_rows_v =
    builder_traits<linalg::remove_cvref_t<Builder>>::CoordRows;
 
template <typename Builder>
inline constexpr std::size_t builder_coord_cols_v =
    builder_traits<linalg::remove_cvref_t<Builder>>::CoordCols;
 
template <typename Builder>
inline constexpr std::size_t builder_coord_aux_dim_v =
    builder_traits<linalg::remove_cvref_t<Builder>>::CoordAuxDim;
 
template <typename Builder>
inline constexpr std::size_t builder_cone_rows_v =
    builder_traits<linalg::remove_cvref_t<Builder>>::ConeRows;
 
template <typename Builder>
inline constexpr std::size_t builder_cone_cols_v =
    builder_traits<linalg::remove_cvref_t<Builder>>::ConeCols;
 
template <typename Builder>
inline constexpr std::size_t builder_cone_aux_dim_v =
    builder_traits<linalg::remove_cvref_t<Builder>>::ConeAuxDim;
 
template <typename Builder>
inline constexpr std::size_t builder_cone_count_v =
    builder_traits<linalg::remove_cvref_t<Builder>>::ConeCount;
 
template <typename Builder>
inline constexpr std::size_t builder_local_cone_dim_v =
    builder_traits<linalg::remove_cvref_t<Builder>>::LocalConeDim;
 
template <typename Builder>
inline constexpr std::size_t builder_cone_dim_v =
    builder_local_cone_dim_v<Builder>;
 
template <typename Builder>
inline constexpr std::size_t builder_eq_rows_v =
    builder_traits<linalg::remove_cvref_t<Builder>>::EqRows;
 
template <typename Builder>
inline constexpr std::size_t builder_eq_cols_v =
    builder_traits<linalg::remove_cvref_t<Builder>>::EqCols;
 
template <typename Builder>
inline constexpr std::size_t builder_eq_aux_dim_v =
    builder_traits<linalg::remove_cvref_t<Builder>>::EqAuxDim;
 
template <typename Builder>
inline constexpr std::size_t builder_full_dim_v =
    builder_traits<linalg::remove_cvref_t<Builder>>::FullDim;
 
} // namespace conic