convex_set.hpp

Go to the documentation of this file.

/*
 * Copyright © 2025-2026 Akreon LLC
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include "akreon/linalg/assert.hpp"
 
#include "akreon/linalg/affine/affine_map.hpp"
#include "akreon/convex/cone_traits.hpp"
#include "akreon/convex/convex_traits.hpp"
#include "akreon/linalg/vector/algebra_util.hpp"
 
namespace convex {
 
template <typename Meta, typename Derived, typename Child>
struct ConvexSet : Atom<Meta, ConvexSet<Meta, Derived, Child>, Child> {
  using BaseT = Atom<Meta, ConvexSet<Meta, Derived, Child>, Child>;
  using typename BaseT::PointT;
  using typename BaseT::T;
 
  static_assert(is_var_type_v<Child>,
                "Convex set assumes variable in its domain");
 
  constexpr explicit ConvexSet(const Child& child_in)
      : BaseT(std::make_tuple(child_in)) {}
 
  constexpr void validate_domain_impl() const {
    AK_ASSERT(self().is_well_formed_impl() &&
              "ConvexSet::validate_domain_impl expects set it to be good");
  }
 
  constexpr bool contains(const PointT& x, T tol = 1e-8) const {
    return self().contains_impl(x, tol);
  }
 
  template <linalg::MatrixContainer Mat>
  constexpr auto transform(const affine::AffineMap<Mat>& map) const {
    return self().transform_impl(map);
  }
 
  template <typename OtherDerived, typename OtherChild>
  constexpr bool operator==(
      const ConvexSet<Meta, OtherDerived, OtherChild>& other) const {
    return self().is_equal_impl(other.self());
  }
 
  template <typename OtherDerived, typename OtherChild>
  constexpr bool operator!=(
      const ConvexSet<Meta, OtherDerived, OtherChild>& other) const {
    return !self().is_equal_impl(other.self());
  }
 
  template <AtomType Type, conic::BuilderLike Builder>
  constexpr auto canonicalize_impl(const Builder& builder) const {
    return self().template canonicalize_set<Type>(builder);
  }
 
  constexpr auto self() const { return static_cast<const Derived&>(*this); }
};
 
} // namespace convex