hyperplane.hpp

Go to the documentation of this file.

/*
 * Copyright © 2025-2026 Akreon LLC
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include "convex_set.hpp"
 
namespace convex {
 
template <linalg::RnSpace Space>
using HyperplaneDom = ConvexDomain<Space, VarType::FREE>;
 
template <linalg::RnSpace Space>
using HyperplaneCodom = HyperplaneDom<Space>;
 
template <linalg::RnSpace Space>
using HyperplaneMeta =
    ConvexAtomMeta<HyperplaneDom<Space>, HyperplaneCodom<Space>,
                   CurvatureType::CONVEX>;
 
template <typename Meta, typename Child>
struct Hyperplane : ConvexSet<Meta, Hyperplane<Meta, Child>, Child> {
  using ConvexBase = ConvexSet<Meta, Hyperplane<Meta, Child>, Child>;
  using ConvexBase::N;
  using typename ConvexBase::PointT;
  using typename ConvexBase::T;
 
  constexpr explicit Hyperplane(const PointT& a_in, T b_in,
                                const Child& child_in)
      : ConvexBase(child_in), a(a_in), b(b_in) {}
 
  constexpr bool contains_impl(const PointT& x, T tol) const {
    return linalg::constexpr_abs(linalg::inner_product(a, x) - b) < tol;
  }
 
  constexpr bool is_well_formed() const {
    if (linalg::all_zero(a)) return false;
    return true;
  }
 
  template <linalg::SquareMatrix Mat>
    requires(linalg::mat_cols_v<Mat> == N &&
             std::same_as<linalg::matrix_scalar_t<Mat>, T>)
  constexpr auto transform_impl(const affine::AffineMap<Mat>& map) const {
    const auto [U_inv, event] = linalg::MatrixInverse<Mat>()(map.linear_part());
    static_cast<void>(event);
    const auto aT_U = transpose(as_col_vector(a)) * U_inv;
    return Hyperplane<Meta, Child>(as_vector(aT_U),
                                   b + (aT_U * map.translation())(0),
                                   std::get<0>(this->children));
  }
 
  template <typename Other>
  constexpr bool is_equal_impl(const Other& other) const {
    return other.self().a == a && other.self().b == b;
  }
 
  template <AtomType Type, conic::BuilderLike Builder>
  constexpr auto canonicalize_set(const Builder& builder) const {
    static_cast<void>(Type);
    const auto child_builder =
        std::get<0>(this->children)
            .template canonicalize<AtomType::SET>(builder);
    const auto child_coord = child_builder.coord_map;
 
    static constexpr std::size_t ChildCodom =
        linalg::mat_cols_v<decltype(child_coord.linear_part())>;
    static_assert(ChildCodom == N,
                  "Convex set domain does not equal the child coordinate "
                  "linear map's codomain in size");
 
    const auto eq_map = affine::AffineMap<linalg::RowVector<T, N>>(
                            linalg::as_row_vector(a), linalg::Vector<T, 1>{b})
                            .compose(child_coord);
    const auto emission = conic::LocalEqualityEmission(eq_map);
    return child_builder.realize(emission);
  }
 
  PointT a; //< n-dim vec of type T
  T b;      //< bias scalar of type T
};
 
template <typename Point, typename T, typename Child>
Hyperplane(const Point&, const T&, const Child&)
    -> Hyperplane<HyperplaneMeta<dom_space_t<meta_codom_t<atom_meta_t<Child>>>>,
                  atom_decay_t<Child>>;
 
} // namespace convex