impl_funcs_lib.hpp

Go to the documentation of this file.

// --------------------------------------------------------------------------
//
// Copyright (C) 2025-present by Pablo Antolin
//
// This file is part of the QUGaR library.
//
// SPDX-License-Identifier:    MIT
//
// --------------------------------------------------------------------------
 
#ifndef QUGAR_IMPL_FUNCS_LIB_HPP
#define QUGAR_IMPL_FUNCS_LIB_HPP
 
 
#include <qugar/affine_transf.hpp>
#include <qugar/domain_function.hpp>
#include <qugar/impl_funcs_lib_macros.hpp>
#include <qugar/point.hpp>
#include <qugar/types.hpp>
#include <qugar/vector.hpp>
 
#include <algoim/interval.hpp>
 
#include <array>
#include <memory>
#include <type_traits>
 
namespace qugar::impl::funcs {
 
namespace _impl {
  // NOLINTNEXTLINE (misc-no-recursion)
  template<class T> constexpr T pow(const T base, unsigned const exponent) noexcept
  {
    return (exponent == 0) ? 1 : (base * pow(base, exponent - 1));
  }
 
  template<typename V> struct IsAlgoimVector;
 
  template<typename T, int dim> struct IsAlgoimVector<Vector<T, dim>>
  {
    using value = std::integral_constant<bool, true>;
  };
 
  template<int dim> struct IsAlgoimVector<Point<dim>>
  {
    using value = std::integral_constant<bool, false>;
  };
 
  template<typename V, int new_dim> struct NewVector;
 
  template<typename T, int dim, int new_dim> struct NewVector<Vector<T, dim>, new_dim>
  {
    using type = Vector<T, new_dim>;
  };
 
  template<int dim, int new_dim> struct NewVector<Point<dim>, new_dim>
  {
    using type = Point<new_dim>;
  };
 
  template<typename V, int new_dim> using NewVector_t = typename NewVector<V, new_dim>::type;
 
 
  template<typename V> struct VectorDim;
 
  template<typename T, int dim_> struct VectorDim<Vector<T, dim_>>
  {
    static const int dim = dim_;
  };
 
  template<int dim_> struct VectorDim<Point<dim_>>
  {
    static const int dim = dim_;
  };
 
  template<typename V> using Hessian_t = typename NewVector<V, (VectorDim<V>::dim * (VectorDim<V>::dim + 1)) / 2>::type;
 
  template<typename V> struct VectorType;
 
  template<typename T, int dim> struct VectorType<Vector<T, dim>>
  {
    using type = T;
  };
 
  template<int dim> struct VectorType<Point<dim>>
  {
    using type = real;
  };
 
  template<typename V> using VectorType_t = typename VectorType<V>::type;
 
 
}// namespace _impl
 
 
template<int dim> class FuncWithAffineTransf : public ImplicitFunc<dim>
{
public:
  FuncWithAffineTransf();
 
  explicit FuncWithAffineTransf(const AffineTransf<dim> &transf);
 
protected:
  AffineTransf<dim> transf_;
};
 
 
template<int dim> class Square : public FuncWithAffineTransf<dim>
{
public:
  Square() = default;
 
  explicit Square(const AffineTransf<dim> &transf);
 
  declare_impl_func_virtual_interface;
 
  template<typename T> static int sgn(const T &val);
};
 
template<int dim> class DimLinear : public FuncWithAffineTransf<dim>
{
public:
  static const int num_coeffs = _impl::pow(2, dim);
 
  explicit DimLinear(const std::array<real, num_coeffs> &coefs);
 
  DimLinear(const std::array<real, num_coeffs> &coefs, const AffineTransf<dim> &transf);
 
  declare_impl_func_virtual_interface;
 
private:
  std::array<real, num_coeffs> coefs_;
};
 
 
template<int dim> class TransformedFunction : public FuncWithAffineTransf<dim>
{
public:
  TransformedFunction(const std::shared_ptr<const ImplicitFunc<dim>> &base_func, const AffineTransf<dim> &transf);
 
  declare_impl_func_virtual_interface;
 
private:
  std::shared_ptr<const ImplicitFunc<dim>> base_func_;
};
 
template<int dim> class Negative : public ImplicitFunc<dim>
{
public:
  explicit Negative(const std::shared_ptr<const ImplicitFunc<dim>> &func);
 
  declare_impl_func_virtual_interface;
 
private:
  std::shared_ptr<const ImplicitFunc<dim>> func_;
};
 
template<int dim> class AddFunctions : public ImplicitFunc<dim>
{
public:
  explicit AddFunctions(const std::shared_ptr<const ImplicitFunc<dim>> &lhs,
    const std::shared_ptr<const ImplicitFunc<dim>> &rhs);
 
  declare_impl_func_virtual_interface;
 
private:
  std::shared_ptr<const ImplicitFunc<dim>> lhs_;
  std::shared_ptr<const ImplicitFunc<dim>> rhs_;
};
 
template<int dim> class SubtractFunctions : public ImplicitFunc<dim>
{
public:
  explicit SubtractFunctions(const std::shared_ptr<const ImplicitFunc<dim>> &lhs,
    const std::shared_ptr<const ImplicitFunc<dim>> &rhs);
 
  declare_impl_func_virtual_interface;
 
private:
  std::shared_ptr<const ImplicitFunc<dim>> lhs_;
  std::shared_ptr<const ImplicitFunc<dim>> rhs_;
};
 
 
}// namespace qugar::impl::funcs
 
 
#endif// QUGAR_IMPL_FUNCS_LIB_HPP