convex_traits.hpp

Go to the documentation of this file.

/*
 * Copyright © 2025-2026 Akreon LLC
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include "akreon/linalg/affine/affine_traits.hpp"
#include "cone_traits.hpp"
#include "akreon/linalg/norms/norm_traits.hpp"
 
namespace convex {
 
template <typename T>
using LiftedVarMat = linalg::RowVector<T, 1>;
 
template <typename T>
using LiftedVarBias = linalg::Vector<T, 1>;
 
enum struct AtomType : uint8_t { VAR = 0, INDEX, FN, SET, ADD, CAP };
 
enum struct VarType : uint8_t { FREE = 0, NONNEG, NONPOS, POS, NEG, PSD };
 
enum struct CurvatureType : uint8_t { AFFINE = 0, CONVEX, CONCAVE };
 
enum struct MonotonicityType : uint8_t { UNKNOWN = 0, NONDEC, NONINC };
 
enum struct InequalityType : uint8_t { EQ = 0, LEQ, GEQ };
 
enum struct StageType : uint8_t { INIT = 0, IN_PROGRESS, PROBLEM_SET };
 
template <linalg::RnSpace Space, VarType Sign>
struct ConvexDomain {};
 
template <typename Dom>
struct dom_traits {};
 
template <linalg::RnSpace SpaceIn, VarType Sign>
struct dom_traits<ConvexDomain<SpaceIn, Sign>> {
  using Space = SpaceIn;
  using T = linalg::space_type_t<Space>;
  using Point = linalg::space_point_t<Space>;
  static constexpr std::size_t N = linalg::space_dim_v<Space>;
  static constexpr VarType sign = Sign;
};
 
template <typename Dom>
using dom_space_t = typename dom_traits<linalg::remove_cvref_t<Dom>>::Space;
 
template <typename Dom>
using dom_type_t = typename dom_traits<linalg::remove_cvref_t<Dom>>::T;
 
template <typename Dom>
using dom_point_t = typename dom_traits<linalg::remove_cvref_t<Dom>>::Point;
 
template <typename Dom>
inline constexpr std::size_t dom_size_v =
    dom_traits<linalg::remove_cvref_t<Dom>>::N;
 
template <typename Dom>
inline constexpr VarType dom_vartype_v =
    dom_traits<linalg::remove_cvref_t<Dom>>::sign;
 
template <typename Dom, typename Codom, CurvatureType Curv>
  requires(std::same_as<dom_type_t<Dom>, dom_type_t<Codom>>)
struct ConvexAtomMeta {};
 
template <typename Meta>
struct meta_traits {};
 
template <typename Dom, typename Codom, CurvatureType Curv>
struct meta_traits<ConvexAtomMeta<Dom, Codom, Curv>> {
  using Domain = Dom;
  using Codomain = Codom;
  static constexpr CurvatureType curvature = Curv;
};
 
template <typename Meta>
using meta_dom_t = typename meta_traits<linalg::remove_cvref_t<Meta>>::Domain;
 
template <typename Meta>
using meta_codom_t =
    typename meta_traits<linalg::remove_cvref_t<Meta>>::Codomain;
 
template <typename Meta>
inline constexpr CurvatureType meta_curv_v =
    meta_traits<linalg::remove_cvref_t<Meta>>::curvature;
 
template <typename Meta, typename Derived, typename... Cs>
struct Atom;
 
template <typename Meta>
struct Variable;
 
template <typename Meta, typename Child>
  requires(dom_size_v<meta_dom_t<Meta>> == 1)
struct ScalarView;
 
template <typename Meta, typename Child>
struct Max;
 
template <typename Meta, typename Child, linalg::NormFunction NormFunc>
  requires(dom_size_v<meta_dom_t<Meta>> == linalg::norm_dim_v<NormFunc>)
struct Norm;
 
template <typename Meta, typename Child>
struct GeoMean;
 
template <typename Meta, typename Child>
  requires(dom_size_v<meta_dom_t<Meta>> == 1)
struct Exp;
 
template <typename Meta, typename Child>
  requires(dom_size_v<meta_dom_t<Meta>> == 1)
struct Log;
 
template <typename Meta, typename Child>
  requires(dom_size_v<meta_dom_t<Meta>> == 1)
struct Square;
 
template <typename Meta, typename Child>
  requires(dom_size_v<meta_dom_t<Meta>> == 1)
struct Abs;
 
template <typename Meta, typename Child>
  requires(dom_size_v<meta_dom_t<Meta>> == 1)
struct InvPos;
 
template <typename Meta, typename Child>
struct LogSumExp;
 
template <typename Meta, typename Child>
  requires(dom_size_v<meta_dom_t<Meta>> == 1)
struct Sqrt;
 
template <typename Meta, typename Child>
  requires(dom_size_v<meta_dom_t<Meta>> == 1)
struct Softplus;
 
template <typename Meta, typename Child>
  requires(dom_size_v<meta_dom_t<Meta>> == 2)
struct HarmonicMean;
 
template <typename Meta, typename Child>
struct KLDivergence;
 
template <typename Meta, typename Child>
struct Huber;
 
template <typename Meta, typename... Cs>
struct Sum;
 
template <typename Meta, typename Derived, typename Child>
struct ConvexSet;
 
template <typename Meta, typename Child>
struct AffineSubspace;
 
template <typename Meta, typename Child>
struct Ellipsoid;
 
enum struct HalfspaceType : uint8_t { LH = 0, UH };
 
template <typename Meta, typename Child, HalfspaceType Type>
struct Halfspace;
 
template <typename Meta, typename Child>
struct Hyperplane;
 
template <typename Meta, typename Child, linalg::SquareMatrix MatIn>
struct LMI;
 
enum struct NormBallType : uint8_t { L2 = 0, L1, Linf };
 
template <typename Meta, typename Child, NormBallType Type>
struct NormBall;
 
template <typename Meta, typename Child>
struct Polyhedron;
 
template <typename Meta, typename... Cs>
struct Intersection;
 
template <conic::BuilderLike Builder, StageType Stage>
struct ConvexProblem;
 
template <typename Prob>
struct prob_traits;
 
template <conic::BuilderLike Builder, StageType Stage>
struct prob_traits<ConvexProblem<Builder, Stage>> {
  using BuilderT = Builder;
  static constexpr StageType StageV = Stage;
};
 
template <typename Prob>
using prob_builder_t =
    typename prob_traits<linalg::remove_cvref_t<Prob>>::BuilderT;
 
template <typename Prob>
inline constexpr bool is_problem_set_v =
    prob_traits<linalg::remove_cvref_t<Prob>>::StageV == StageType::PROBLEM_SET;
 
template <typename Problem>
concept ProblemLike = requires(const Problem& prob) {
  { prob.linear_objective() };
  { prob.constraint_map() };
  { prob.constraint_cones() };
  { prob.equality_map() };
};
 
template <typename Atom>
struct atom_traits {};
 
template <typename Meta, typename Child>
struct atom_traits<Atom<Meta, Child>> {
  using ConvexMeta = Meta;
};
 
template <typename Meta>
struct atom_traits<Variable<Meta>> : std::false_type {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::VAR;
};
 
template <typename Meta, typename Child>
struct atom_traits<ScalarView<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::INDEX;
};
 
template <typename Meta, typename Child>
struct atom_traits<Abs<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::FN;
};
 
template <typename Meta, typename Child>
struct atom_traits<Exp<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::FN;
};
 
template <typename Meta, typename Child>
struct atom_traits<GeoMean<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::FN;
};
 
template <typename Meta, typename Child>
struct atom_traits<InvPos<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::FN;
};
 
template <typename Meta, typename Child>
struct atom_traits<Log<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::FN;
};
 
template <typename Meta, typename Child>
struct atom_traits<LogSumExp<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::FN;
};
 
template <typename Meta, typename Child>
struct atom_traits<Max<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::FN;
};
 
template <typename Meta, typename Child>
struct atom_traits<Square<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::FN;
};
 
template <typename Meta, typename Child, linalg::NormFunction NormFunc>
struct atom_traits<Norm<Meta, Child, NormFunc>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::FN;
};
 
template <typename Meta, typename Child>
struct atom_traits<Sqrt<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::FN;
};
 
template <typename Meta, typename Child>
struct atom_traits<Softplus<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::FN;
};
 
template <typename Meta, typename Child>
struct atom_traits<HarmonicMean<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::FN;
};
 
template <typename Meta, typename Child>
struct atom_traits<KLDivergence<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::FN;
};
 
template <typename Meta, typename Child>
struct atom_traits<Huber<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::FN;
};
 
template <typename Meta, typename Derived, typename Child>
struct atom_traits<ConvexSet<Meta, Derived, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::SET;
};
 
template <typename Meta, typename Child>
struct atom_traits<AffineSubspace<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::SET;
};
 
template <typename Meta, typename Child>
struct atom_traits<Ellipsoid<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::SET;
};
 
template <typename Meta, typename Child, HalfspaceType HType>
struct atom_traits<Halfspace<Meta, Child, HType>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::SET;
};
 
template <typename Meta, typename Child>
struct atom_traits<Hyperplane<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::SET;
};
 
template <typename Meta, typename Child, typename Mat>
struct atom_traits<LMI<Meta, Child, Mat>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::SET;
};
 
template <typename Meta, typename Child, NormBallType BType>
struct atom_traits<NormBall<Meta, Child, BType>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::SET;
};
 
template <typename Meta, typename Child>
struct atom_traits<Polyhedron<Meta, Child>> {
  using ConvexMeta = Meta;
  static constexpr AtomType Type = AtomType::SET;
};
 
template <linalg::RnSpace Dom>
using SumDom = ConvexDomain<Dom, VarType::FREE>;
 
template <linalg::RnSpace Codom>
  requires(linalg::space_dim_v<Codom> == 1)
using SumCodom = ConvexDomain<Codom, VarType::FREE>;
 
template <linalg::RnSpace Dom, linalg::RnSpace Codom>
using SumMeta =
    ConvexAtomMeta<SumDom<Dom>, SumCodom<Codom>, CurvatureType::AFFINE>;
 
template <linalg::RnSpace Dom, linalg::RnSpace Codom, typename... Cs>
struct atom_traits<Sum<SumMeta<Dom, Codom>, Cs...>> {
  using ConvexMeta = SumMeta<Dom, Codom>;
  static constexpr AtomType Type = AtomType::ADD;
};
 
template <linalg::RnSpace Space>
using IntersectionDom = ConvexDomain<Space, VarType::FREE>;
 
template <linalg::RnSpace Space>
using IntersectionCodom = IntersectionDom<Space>;
 
template <linalg::RnSpace Space>
using IntersectionMeta =
    ConvexAtomMeta<IntersectionDom<Space>, IntersectionCodom<Space>,
                   CurvatureType::CONVEX>;
 
template <linalg::RnSpace Space, typename... Cs>
struct atom_traits<Intersection<IntersectionMeta<Space>, Cs...>> {
  using ConvexMeta = IntersectionMeta<Space>;
  static constexpr AtomType Type = AtomType::CAP;
};
 
template <typename Atom>
concept AtomLike = requires(const Atom& atom) {
  { atom.validate_domain() } -> std::convertible_to<void>;
  { atom.children };
};
 
template <InequalityType IType, AtomLike LHS, typename RHS>
struct Inequality;
 
template <typename T>
using atom_decay_t = linalg::remove_cvref_t<T>;
 
template <AtomLike Atom>
using atom_meta_t = typename atom_traits<atom_decay_t<Atom>>::ConvexMeta;
 
template <AtomLike Atom>
inline constexpr AtomType atom_type_v = atom_traits<atom_decay_t<Atom>>::Type;
 
template <AtomLike Atom>
inline constexpr bool is_fn_type_v = atom_type_v<Atom> == AtomType::FN;
 
template <AtomLike Atom>
inline constexpr bool is_var_type_v = atom_type_v<Atom> == AtomType::VAR;
 
template <AtomLike Atom>
inline constexpr bool is_set_type_v = atom_type_v<Atom> == AtomType::SET;
 
template <AtomLike Atom>
inline constexpr bool is_add_type_v = atom_type_v<Atom> == AtomType::ADD;
 
template <AtomLike Atom>
inline constexpr bool is_cap_type_v = atom_type_v<Atom> == AtomType::CAP;
 
template <AtomLike Atom>
inline constexpr bool is_index_type_v = atom_type_v<Atom> == AtomType::INDEX;
 
} // namespace convex