MathUtils.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.

#ifndef CUBBYFLOW_MATH_UTILS_HPP
#define CUBBYFLOW_MATH_UTILS_HPP

#include <Core/Utils/Macros.hpp>

#include <cstddef>
#include <limits>
#include <type_traits>

namespace CubbyFlow
{
template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, bool> Similar(
    T x, T y, T eps = std::numeric_limits<T>::epsilon());

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, T> Sign(T x);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, T> Min3(T x, T y, T z);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, T> Max3(T x, T y, T z);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, T> MinN(const T* x, size_t n);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, T> MaxN(const T* x, size_t n);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, T> AbsMin(T x, T y);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, T> AbsMax(T x, T y);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, T> AbsMinN(const T* x, size_t n);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, T> AbsMaxN(const T* x, size_t n);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, size_t> ArgMin2(T x, T y);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, size_t> ArgMax2(T x, T y);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, size_t> ArgMin3(T x, T y, T z);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, size_t> ArgMax3(T x, T y, T z);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, T> Square(T x);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, T> Cubic(T x);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, T> Clamp(T val, T low, T high);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, T> DegreesToRadians(
    T angleInDegrees);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, T> RadiansToDegrees(
    T angleInRadians);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value> GetBarycentric(T x, size_t begin,
                                                              size_t end,
                                                              size_t& i, T& t);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value> GetBarycentric(T x,
                                                              ssize_t begin,
                                                              ssize_t end,
                                                              ssize_t& i, T& t);

template <typename S, typename T>
std::enable_if_t<std::is_arithmetic<T>::value, S> Lerp(const S& f0, const S& f1,
                                                       T t);

template <typename S, typename T>
std::enable_if_t<std::is_arithmetic<T>::value, S> BiLerp(
    const S& f00, const S& f10, const S& f01, const S& f11, T tx, T ty);

template <typename S, typename T>
std::enable_if_t<std::is_arithmetic<T>::value, S> TriLerp(
    const S& f000, const S& f100, const S& f010, const S& f110, const S& f001,
    const S& f101, const S& f011, const S& f111, T tx, T ty, T tz);

template <typename S, typename T>
std::enable_if_t<std::is_arithmetic<T>::value, S> CatmullRom(const S& f0,
                                                             const S& f1,
                                                             const S& f2,
                                                             const S& f3, T t);

template <typename T>
std::enable_if_t<std::is_arithmetic<T>::value, T> MonotonicCatmullRom(
    const T& f0, const T& f1, const T& f2, const T& f3, T t);
}  // namespace CubbyFlow

#include <Core/Math/MathUtils-Impl.hpp>

#endif