tpms_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_TPMS_LIB_HPP
#define QUGAR_IMPL_TPMS_LIB_HPP
 
 
#include <qugar/domain_function.hpp>
#include <qugar/vector.hpp>
 
#include <qugar/numbers.hpp>
#include <qugar/point.hpp>
#include <qugar/types.hpp>
 
namespace qugar::impl::tpms {
 
template<int dim> class TPMSBase : public qugar::impl::ImplicitFunc<dim>
{
protected:
  template<int dim_aux = dim>
    requires(dim == dim_aux && dim_aux == 2)
  TPMSBase(const Vector<real, 2> &mnq, real z) : z_(z)
  {
    mnq_(0) = mnq(0);
    mnq_(1) = mnq(1);
  }
 
  template<int dim_aux = dim>
    requires(dim == dim_aux && dim_aux == 3)
  explicit TPMSBase(const Vector<real, 3> &mnq) : mnq_(mnq)
  {}
 
  TPMSBase() = default;
 
  Vector<real, 3> mnq_{ numbers::one };
 
  real z_{ numbers::zero };
};
 
// NOLINTNEXTLINE (cppcoreguidelines-macro-usage)
#define declare_tpms(TPMS_NAME)                                                                 \
  template<int dim> class TPMS_NAME : public TPMSBase<dim>                                      \
  {                                                                                             \
    using Parent = TPMSBase<dim>;                                                               \
    template<typename T> using Gradient = qugar::impl::ImplicitFunc<dim>::template Gradient<T>; \
    template<typename T> using Hessian = qugar::impl::ImplicitFunc<dim>::template Hessian<T>;   \
                                                                                                \
  public:                                                                                       \
    TPMS_NAME() = default;                                                                      \
                                                                                                \
    template<int dim_aux = dim>                                                                 \
      requires(dim == dim_aux && dim_aux == 2)                                                  \
    explicit TPMS_NAME(const Vector<real, dim> &mnq, real z) : Parent(mnq, z)                   \
    {}                                                                                          \
                                                                                                \
    template<int dim_aux = dim>                                                                 \
      requires(dim == dim_aux && dim_aux == 3)                                                  \
    explicit TPMS_NAME(const Vector<real, dim> &mnq) : Parent(mnq)                              \
    {}                                                                                          \
                                                                                                \
    [[nodiscard]] virtual real operator()(const Point<dim> &point) const final;                 \
                                                                                                \
    [[nodiscard]] virtual ::algoim::Interval<dim> operator()(                                   \
      const Point<dim, ::algoim::Interval<dim>> &point) const final;                            \
                                                                                                \
    [[nodiscard]] virtual Gradient<real> grad(const Point<dim> &point) const final;             \
                                                                                                \
    [[nodiscard]] virtual Gradient<::algoim::Interval<dim>> grad(                               \
      const Point<dim, ::algoim::Interval<dim>> &point) const final;                            \
                                                                                                \
    [[nodiscard]] virtual Hessian<real> hessian(const Point<dim> &point) const final;           \
                                                                                                \
  private:                                                                                      \
    template<typename T> [[nodiscard]] T eval_(const Point<3, T> &point) const;                 \
                                                                                                \
    template<typename T> [[nodiscard]] Gradient<T> grad_(const Point<3, T> &point) const;       \
                                                                                                \
    template<typename T> [[nodiscard]] Hessian<T> hessian_(const Point<3, T> &point) const;     \
  };
 
declare_tpms(Schoen);
 
declare_tpms(SchoenIWP);
 
declare_tpms(SchoenFRD);
 
declare_tpms(FischerKochS);
 
declare_tpms(SchwarzDiamond);
 
declare_tpms(SchwarzPrimitive);
 
}// namespace qugar::impl::tpms
 
 
#endif// QUGAR_IMPL_TPMS_LIB_HPP