EBGeometry_Blend.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2022 Robert Marskar <robert.marskar@sintef.no>
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef EBGEOMETRY_BLEND_HPP
#define EBGEOMETRY_BLEND_HPP
 
// Std includes
#include <cmath>
#include <type_traits>
 
// Our includes
#include "EBGeometry_GPU.hpp"
#include "EBGeometry_Macros.hpp"
#include "EBGeometry_Math.hpp"
 
namespace EBGeometry {
 
template <class T>
struct ExpMinOp
{
  static_assert(std::is_floating_point_v<T>, "ExpMinOp requires a floating-point type T");
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  T
  operator()(const T& a, const T& b, const T& s) const noexcept
  {
    EBGEOMETRY_EXPECT(s > T(0));
 
    return Math::min(a, b) - s * std::log1p(std::exp(-std::abs(a - b) / s));
  }
};
 
template <class T>
struct ExpMaxOp
{
  static_assert(std::is_floating_point_v<T>, "ExpMaxOp requires a floating-point type T");
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  T
  operator()(const T& a, const T& b, const T& s) const noexcept
  {
    EBGEOMETRY_EXPECT(s > T(0));
 
    return Math::max(a, b) + s * std::log1p(std::exp(-std::abs(a - b) / s));
  }
};
 
template <class T>
struct SmoothMinOp
{
  static_assert(std::is_floating_point_v<T>, "SmoothMinOp requires a floating-point type T");
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  T
  operator()(const T& a, const T& b, const T& s) const noexcept
  {
    EBGEOMETRY_EXPECT(s > T(0));
 
    const T h = Math::max(s - std::abs(a - b), T(0)) / s;
 
    return Math::min(a, b) - T(0.25) * h * h * s;
  }
};
 
template <class T>
struct SmoothMaxOp
{
  static_assert(std::is_floating_point_v<T>, "SmoothMaxOp requires a floating-point type T");
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  T
  operator()(const T& a, const T& b, const T& s) const noexcept
  {
    EBGEOMETRY_EXPECT(s > T(0));
 
    const T h = Math::max(s - std::abs(a - b), T(0)) / s;
 
    return Math::max(a, b) + T(0.25) * h * h * s;
  }
};
 
template <class T>
inline constexpr ExpMinOp<T> ExpMin{};
 
template <class T>
inline constexpr ExpMaxOp<T> ExpMax{};
 
template <class T>
inline constexpr SmoothMinOp<T> SmoothMin{};
 
template <class T>
inline constexpr SmoothMaxOp<T> SmoothMax{};
 
} // namespace EBGeometry
 
#endif