convex_problem.hpp

Go to the documentation of this file.

/*
 * Copyright © 2025-2026 Akreon LLC
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include "canonical_form_builder.hpp"
 
namespace convex {
 
template <AtomLike Var>
constexpr auto make_problem(const Var& x) {
  using Space = dom_space_t<meta_dom_t<atom_meta_t<Var>>>;
  const auto builder = conic::create_empty_cblk_builder<Space>();
  const auto new_builder = x.template add_var_block<AtomType::VAR>(builder);
  return ConvexProblem<decltype(new_builder), StageType::INIT>(new_builder);
}
 
template <conic::BuilderLike Builder, StageType Stage>
struct ConvexProblem {
  using T = linalg::space_type_t<conic::builder_dom_t<Builder>>;
 
  constexpr explicit ConvexProblem(const Builder& builder_in)
      : builder(builder_in) {}
 
  template <AtomLike Atom>
  constexpr auto in_set(const Atom& atom) const {
    if constexpr (!(is_set_type_v<Atom> || is_cap_type_v<Atom>))
      static_assert(false, "Atom is not a set type");
    else {
      const auto new_builder =
          atom.template canonicalize<AtomType::SET>(builder);
      return ConvexProblem<decltype(new_builder), StageType::IN_PROGRESS>(
          new_builder);
    }
  }
 
  template <InequalityType IType, AtomLike LHS, typename RHS>
  constexpr auto add_constraint(const Inequality<IType, LHS, RHS>& ineq) const {
    const auto new_builder = ineq.template canonicalize<AtomType::CAP>(builder);
    return ConvexProblem<decltype(new_builder), StageType::IN_PROGRESS>(
        new_builder);
  }
 
  constexpr auto feasibility() const {
    const auto cb = builder.cb;
    static constexpr std::size_t ConeN =
        linalg::mat_cols_v<decltype(cb.map.linear_part())>;
    static constexpr std::size_t EqN =
        linalg::mat_cols_v<decltype(builder.eq_map.linear_part())>;
    static constexpr std::size_t AugN = (ConeN > EqN) ? ConeN : EqN;
    linalg::RowVector<T, AugN> c{};
    affine::AffineMap<decltype(c)> new_map(c);
 
    const auto new_builder = conic::make_builder<conic::builder_dom_t<Builder>>(
        new_map, cb, builder.eq_map, builder.canonical_trace);
    return ConvexProblem<decltype(new_builder), StageType::PROBLEM_SET>(
        new_builder);
  }
 
  template <AtomLike Atom>
  constexpr auto minimize(const Atom& atom) const {
    if constexpr (is_set_type_v<Atom> || is_cap_type_v<Atom>) {
      static_assert(false,
                    "Attempting to minimize a set or intersection of sets");
    } else if constexpr (is_var_type_v<Atom>) {
      static_assert(
          false,
          "Attempting to minimize over a var type, please use affine op, "
          "convex function, or index of var instead of raw type");
    } else if constexpr (is_index_type_v<Atom>) {
      const auto cb = builder.cb;
      static constexpr std::size_t ConeN =
          linalg::mat_cols_v<decltype(cb.map.linear_part())>;
      static constexpr std::size_t EqN =
          linalg::mat_cols_v<decltype(builder.eq_map.linear_part())>;
      static constexpr std::size_t AugN = (ConeN > EqN) ? ConeN : EqN;
      linalg::RowVector<T, AugN> c{};
      auto b = builder.coord_map.translation()(0) + atom.map.translation()(0);
      static constexpr std::size_t N =
          linalg::space_dim_v<conic::builder_dom_t<Builder>>;
      constexpr std::size_t CopyN = (N < AugN) ? N : AugN;
      for (std::size_t i = 0; i < CopyN; ++i)
        c(0, i) = atom.map.linear_part()(0, i);
      const affine::AffineMap<decltype(c)> new_map(c, b);
      const auto new_builder =
          conic::make_builder<conic::builder_dom_t<Builder>>(
              new_map, cb, builder.eq_map, builder.canonical_trace);
      return ConvexProblem<decltype(new_builder), StageType::PROBLEM_SET>(
          new_builder);
    } else {
      static constexpr CurvatureType Tag = meta_curv_v<atom_meta_t<Atom>>;
      if constexpr (Tag == CurvatureType::CONCAVE) {
        static_assert(false, "Attempting to minimize a concave function");
      } else {
        const auto obj_builder =
            atom.template canonicalize<AtomType::CAP>(builder);
        static constexpr std::size_t ConeN =
            linalg::mat_cols_v<decltype(obj_builder.cb.map.linear_part())>;
        static constexpr std::size_t EqN =
            linalg::mat_cols_v<decltype(obj_builder.eq_map.linear_part())>;
        static constexpr std::size_t FullN = (ConeN > EqN) ? ConeN : EqN;
        static constexpr std::size_t ObjN =
            linalg::mat_cols_v<decltype(obj_builder.coord_map.linear_part())>;
 
        linalg::RowVector<T, FullN> c{};
        constexpr std::size_t CopyN = (ObjN < FullN) ? ObjN : FullN;
        for (std::size_t i = 0; i < CopyN; ++i)
          c(0, i) = obj_builder.coord_map.linear_part()(0, i);
 
        const auto b = obj_builder.coord_map.translation()(0);
        const auto obj_map = affine::AffineMap<decltype(c)>(c, b);
        const auto new_builder =
            conic::make_builder<conic::builder_dom_t<decltype(obj_builder)>>(
                obj_map, obj_builder.cb, obj_builder.eq_map,
                obj_builder.canonical_trace);
        return ConvexProblem<decltype(new_builder), StageType::PROBLEM_SET>(
            new_builder);
      }
    }
  }
 
  template <AtomLike Atom>
  constexpr auto maximize(const Atom& atom) const {
    if constexpr (is_set_type_v<Atom> || is_cap_type_v<Atom>) {
      static_assert(false,
                    "Attempting to maximize a set or intersection of sets");
    } else if constexpr (is_var_type_v<Atom>) {
      static_assert(
          false,
          "Attempting to maximize over a var type, please use affine op, "
          "concave function, or index of var instead of raw type");
    } else {
      static constexpr CurvatureType Tag = meta_curv_v<atom_meta_t<Atom>>;
      if constexpr (Tag == CurvatureType::CONVEX) {
        static_assert(false, "Attempting to maximize a convex function");
      } else {
        if constexpr (is_fn_type_v<Atom> || is_add_type_v<Atom>)
          return minimize(atom.template mul<-1.0>());
        else return minimize(atom.mul(-1.0));
      }
    }
  }
 
  constexpr bool validate() const { return builder.cb.validate(); }
 
  constexpr auto linear_objective() const
    requires(Stage == StageType::PROBLEM_SET)
  {
    return linalg::as_vector(builder.coord_map.linear_part());
  }
 
  constexpr auto constraint_map() const
    requires(Stage == StageType::PROBLEM_SET)
  {
    return builder.cb.map;
  }
 
  constexpr auto constraint_cones() const
    requires(Stage == StageType::PROBLEM_SET)
  {
    return builder.cb.cones;
  }
 
  constexpr auto equality_map() const
    requires(Stage == StageType::PROBLEM_SET)
  {
    return builder.eq_map;
  }
 
  constexpr auto canonical_trace() const
    requires(Stage == StageType::PROBLEM_SET)
  {
    return builder.canonical_trace;
  }
 
  Builder builder;
};
 
} // namespace convex