FM / util

/usr/local/lib64/python3.6/site-packages/torch/include/c10/util/

/usr/local/lib64/python3.6/site-packages/torch/include/c10/util

Name	Size	Mode	Actions
accumulate.h	4205	0644	edit dl rm
AlignOf.h	4835	0644	edit dl rm
Array.h	11354	0644	edit dl rm
ArrayRef.h	9058	0644	edit dl rm
Backtrace.h	364	0644	edit dl rm
BFloat16-inl.h	9222	0644	edit dl rm
BFloat16-math.h	5217	0644	edit dl rm
BFloat16.h	2372	0644	edit dl rm
Bitset.h	3414	0644	edit dl rm
C++17.h	13329	0644	edit dl rm
complex.h	17542	0644	edit dl rm
complex_math.h	10902	0644	edit dl rm
complex_utils.h	958	0644	edit dl rm
ConstexprCrc.h	6633	0644	edit dl rm
copysign.h	866	0644	edit dl rm
DeadlockDetection.h	1920	0644	edit dl rm
Deprecated.h	3579	0644	edit dl rm
either.h	6423	0644	edit dl rm
env.h	835	0644	edit dl rm
Exception.h	24723	0644	edit dl rm
ExclusivelyOwned.h	4759	0644	edit dl rm
Flags.h	10056	0644	edit dl rm
flat_hash_map.h	61655	0644	edit dl rm
FunctionRef.h	2301	0644	edit dl rm
Half-inl.h	8674	0644	edit dl rm
Half.h	18965	0644	edit dl rm
hash.h	5084	0644	edit dl rm
IdWrapper.h	2348	0644	edit dl rm
intrusive_ptr.h	35563	0644	edit dl rm
in_place.h	350	0644	edit dl rm
irange.h	2679	0644	edit dl rm
LeftRight.h	6016	0644	edit dl rm
llvmMathExtras.h	29168	0644	edit dl rm
Logging.h	11256	0644	edit dl rm
logging_is_google_glog.h	2031	0644	edit dl rm
logging_is_not_google_glog.h	8271	0644	edit dl rm
MathConstants.h	858	0644	edit dl rm
math_compat.h	7296	0644	edit dl rm
MaybeOwned.h	6689	0644	edit dl rm
Metaprogramming.h	15288	0644	edit dl rm
numa.h	696	0644	edit dl rm
Optional.h	35592	0644	edit dl rm
order_preserving_flat_hash_map.h	65482	0644	edit dl rm
overloaded.h	709	0644	edit dl rm
python_stub.h	56	0644	edit dl rm
qint8.h	472	0644	edit dl rm
qint32.h	319	0644	edit dl rm
quint4x2.h	366	0644	edit dl rm
quint8.h	320	0644	edit dl rm
Registry.h	12242	0644	edit dl rm
reverse_iterator.h	8796	0644	edit dl rm
ScopeExit.h	1345	0644	edit dl rm
signal_handler.h	3154	0644	edit dl rm
SmallBuffer.h	1243	0644	edit dl rm
SmallVector.h	34456	0644	edit dl rm
sparse_bitset.h	26511	0644	edit dl rm
StringUtil.h	4538	0644	edit dl rm
string_utils.h	3989	0644	edit dl rm
string_view.h	20189	0644	edit dl rm
tempfile.h	6029	0644	edit dl rm
ThreadLocal.h	3883	0644	edit dl rm
ThreadLocalDebugInfo.h	2603	0644	edit dl rm
thread_name.h	148	0644	edit dl rm
Type.h	607	0644	edit dl rm
TypeCast.h	6972	0644	edit dl rm
typeid.h	18793	0644	edit dl rm
TypeIndex.h	5251	0644	edit dl rm
TypeList.h	16901	0644	edit dl rm
TypeTraits.h	5368	0644	edit dl rm
Unicode.h	295	0644	edit dl rm
UniqueVoidPtr.h	4117	0644	edit dl rm
Unroll.h	667	0644	edit dl rm
variant.h	95182	0644	edit dl rm
win32-headers.h	858	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/torch/include/c10/util/complex_math.h (10902B)

#if !defined(C10_INTERNAL_INCLUDE_COMPLEX_REMAINING_H)
#error \
    "c10/util/complex_math.h is not meant to be individually included. Include c10/util/complex.h instead."
#endif

namespace c10_complex_math {

// Exponential functions

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> exp(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::exp(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#else
  return static_cast<c10::complex<T>>(
      std::exp(static_cast<std::complex<T>>(x)));
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> log(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::log(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#else
  return static_cast<c10::complex<T>>(
      std::log(static_cast<std::complex<T>>(x)));
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> log10(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::log10(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#else
  return static_cast<c10::complex<T>>(
      std::log10(static_cast<std::complex<T>>(x)));
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> log2(const c10::complex<T>& x) {
  const c10::complex<T> log2 = c10::complex<T>(::log(2.0), 0.0);
  return c10_complex_math::log(x) / log2;
}

// Power functions
//
#if defined(_LIBCPP_VERSION) || \
    (defined(__GLIBCXX__) && !defined(_GLIBCXX11_USE_C99_COMPLEX))
namespace _detail {
TORCH_API c10::complex<float> sqrt(const c10::complex<float>& in);
TORCH_API c10::complex<double> sqrt(const c10::complex<double>& in);
TORCH_API c10::complex<float> acos(const c10::complex<float>& in);
TORCH_API c10::complex<double> acos(const c10::complex<double>& in);
}; // namespace _detail
#endif

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> sqrt(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::sqrt(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#elif !(                        \
    defined(_LIBCPP_VERSION) || \
    (defined(__GLIBCXX__) && !defined(_GLIBCXX11_USE_C99_COMPLEX)))
  return static_cast<c10::complex<T>>(
      std::sqrt(static_cast<std::complex<T>>(x)));
#else
  return _detail::sqrt(x);
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> pow(
    const c10::complex<T>& x,
    const c10::complex<T>& y) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::pow(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x),
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y)));
#else
  return static_cast<c10::complex<T>>(std::pow(
      static_cast<std::complex<T>>(x), static_cast<std::complex<T>>(y)));
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> pow(
    const c10::complex<T>& x,
    const T& y) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::pow(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x), y));
#else
  return static_cast<c10::complex<T>>(
      std::pow(static_cast<std::complex<T>>(x), y));
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> pow(
    const T& x,
    const c10::complex<T>& y) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::pow(
      x, c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y)));
#else
  return static_cast<c10::complex<T>>(
      std::pow(x, static_cast<std::complex<T>>(y)));
#endif
}

template <typename T, typename U>
C10_HOST_DEVICE inline c10::complex<decltype(T() * U())> pow(
    const c10::complex<T>& x,
    const c10::complex<U>& y) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::pow(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x),
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y)));
#else
  return static_cast<c10::complex<T>>(std::pow(
      static_cast<std::complex<T>>(x), static_cast<std::complex<T>>(y)));
#endif
}

template <typename T, typename U>
C10_HOST_DEVICE inline c10::complex<decltype(T() * U())> pow(
    const c10::complex<T>& x,
    const U& y) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::pow(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x), y));
#else
  return static_cast<c10::complex<T>>(
      std::pow(static_cast<std::complex<T>>(x), y));
#endif
}

template <typename T, typename U>
C10_HOST_DEVICE inline c10::complex<decltype(T() * U())> pow(
    const T& x,
    const c10::complex<U>& y) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::pow(
      x, c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y)));
#else
  return static_cast<c10::complex<T>>(
      std::pow(x, static_cast<std::complex<T>>(y)));
#endif
}

// Trigonometric functions

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> sin(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::sin(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#else
  return static_cast<c10::complex<T>>(
      std::sin(static_cast<std::complex<T>>(x)));
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> cos(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::cos(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#else
  return static_cast<c10::complex<T>>(
      std::cos(static_cast<std::complex<T>>(x)));
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> tan(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::tan(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#else
  return static_cast<c10::complex<T>>(
      std::tan(static_cast<std::complex<T>>(x)));
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> asin(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::asin(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#else
  return static_cast<c10::complex<T>>(
      std::asin(static_cast<std::complex<T>>(x)));
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> acos(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::acos(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#elif !defined(_LIBCPP_VERSION)
  return static_cast<c10::complex<T>>(
      std::acos(static_cast<std::complex<T>>(x)));
#else
  return _detail::acos(x);
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> atan(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::atan(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#else
  return static_cast<c10::complex<T>>(
      std::atan(static_cast<std::complex<T>>(x)));
#endif
}

// Hyperbolic functions

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> sinh(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::sinh(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#else
  return static_cast<c10::complex<T>>(
      std::sinh(static_cast<std::complex<T>>(x)));
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> cosh(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::cosh(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#else
  return static_cast<c10::complex<T>>(
      std::cosh(static_cast<std::complex<T>>(x)));
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> tanh(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::tanh(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#else
  return static_cast<c10::complex<T>>(
      std::tanh(static_cast<std::complex<T>>(x)));
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> asinh(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::asinh(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#else
  return static_cast<c10::complex<T>>(
      std::asinh(static_cast<std::complex<T>>(x)));
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> acosh(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::acosh(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#else
  return static_cast<c10::complex<T>>(
      std::acosh(static_cast<std::complex<T>>(x)));
#endif
}

template <typename T>
C10_HOST_DEVICE inline c10::complex<T> atanh(const c10::complex<T>& x) {
#if defined(__CUDACC__) || defined(__HIPCC__)
  return static_cast<c10::complex<T>>(thrust::atanh(
      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
#else
  return static_cast<c10::complex<T>>(
      std::atanh(static_cast<std::complex<T>>(x)));
#endif
}

} // namespace c10_complex_math

using c10_complex_math::acos;
using c10_complex_math::acosh;
using c10_complex_math::asin;
using c10_complex_math::asinh;
using c10_complex_math::atan;
using c10_complex_math::atanh;
using c10_complex_math::cos;
using c10_complex_math::cosh;
using c10_complex_math::exp;
using c10_complex_math::log;
using c10_complex_math::log10;
using c10_complex_math::log2;
using c10_complex_math::pow;
using c10_complex_math::sin;
using c10_complex_math::sinh;
using c10_complex_math::sqrt;
using c10_complex_math::tan;
using c10_complex_math::tanh;

namespace std {

} // namespace std

#if !defined(C10_INTERNAL_INCLUDE_COMPLEX_REMAINING_H) #error \ "c10/util/complex_math.h is not meant to be individually included. Include c10/util/complex.h instead." #endif namespace c10_complex_math { // Exponential functions template C10_HOST_DEVICE inline c10::complex exp(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::exp( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #else return static_cast>( std::exp(static_cast>(x))); #endif } template C10_HOST_DEVICE inline c10::complex log(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::log( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #else return static_cast>( std::log(static_cast>(x))); #endif } template C10_HOST_DEVICE inline c10::complex log10(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::log10( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #else return static_cast>( std::log10(static_cast>(x))); #endif } template C10_HOST_DEVICE inline c10::complex log2(const c10::complex& x) { const c10::complex log2 = c10::complex(::log(2.0), 0.0); return c10_complex_math::log(x) / log2; } // Power functions // #if defined(_LIBCPP_VERSION) || \ (defined(__GLIBCXX__) && !defined(_GLIBCXX11_USE_C99_COMPLEX)) namespace _detail { TORCH_API c10::complex sqrt(const c10::complex& in); TORCH_API c10::complex sqrt(const c10::complex& in); TORCH_API c10::complex acos(const c10::complex& in); TORCH_API c10::complex acos(const c10::complex& in); }; // namespace _detail #endif template C10_HOST_DEVICE inline c10::complex sqrt(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::sqrt( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #elif !( \ defined(_LIBCPP_VERSION) || \ (defined(__GLIBCXX__) && !defined(_GLIBCXX11_USE_C99_COMPLEX))) return static_cast>( std::sqrt(static_cast>(x))); #else return _detail::sqrt(x); #endif } template C10_HOST_DEVICE inline c10::complex pow( const c10::complex& x, const c10::complex& y) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::pow( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x), c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y))); #else return static_cast>(std::pow( static_cast>(x), static_cast>(y))); #endif } template C10_HOST_DEVICE inline c10::complex pow( const c10::complex& x, const T& y) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::pow( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x), y)); #else return static_cast>( std::pow(static_cast>(x), y)); #endif } template C10_HOST_DEVICE inline c10::complex pow( const T& x, const c10::complex& y) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::pow( x, c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y))); #else return static_cast>( std::pow(x, static_cast>(y))); #endif } template C10_HOST_DEVICE inline c10::complex pow( const c10::complex& x, const c10::complex& y) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::pow( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x), c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y))); #else return static_cast>(std::pow( static_cast>(x), static_cast>(y))); #endif } template C10_HOST_DEVICE inline c10::complex pow( const c10::complex& x, const U& y) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::pow( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x), y)); #else return static_cast>( std::pow(static_cast>(x), y)); #endif } template C10_HOST_DEVICE inline c10::complex pow( const T& x, const c10::complex& y) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::pow( x, c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y))); #else return static_cast>( std::pow(x, static_cast>(y))); #endif } // Trigonometric functions template C10_HOST_DEVICE inline c10::complex sin(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::sin( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #else return static_cast>( std::sin(static_cast>(x))); #endif } template C10_HOST_DEVICE inline c10::complex cos(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::cos( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #else return static_cast>( std::cos(static_cast>(x))); #endif } template C10_HOST_DEVICE inline c10::complex tan(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::tan( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #else return static_cast>( std::tan(static_cast>(x))); #endif } template C10_HOST_DEVICE inline c10::complex asin(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::asin( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #else return static_cast>( std::asin(static_cast>(x))); #endif } template C10_HOST_DEVICE inline c10::complex acos(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::acos( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #elif !defined(_LIBCPP_VERSION) return static_cast>( std::acos(static_cast>(x))); #else return _detail::acos(x); #endif } template C10_HOST_DEVICE inline c10::complex atan(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::atan( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #else return static_cast>( std::atan(static_cast>(x))); #endif } // Hyperbolic functions template C10_HOST_DEVICE inline c10::complex sinh(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::sinh( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #else return static_cast>( std::sinh(static_cast>(x))); #endif } template C10_HOST_DEVICE inline c10::complex cosh(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::cosh( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #else return static_cast>( std::cosh(static_cast>(x))); #endif } template C10_HOST_DEVICE inline c10::complex tanh(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::tanh( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #else return static_cast>( std::tanh(static_cast>(x))); #endif } template C10_HOST_DEVICE inline c10::complex asinh(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::asinh( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #else return static_cast>( std::asinh(static_cast>(x))); #endif } template C10_HOST_DEVICE inline c10::complex acosh(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::acosh( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #else return static_cast>( std::acosh(static_cast>(x))); #endif } template C10_HOST_DEVICE inline c10::complex atanh(const c10::complex& x) { #if defined(__CUDACC__) || defined(__HIPCC__) return static_cast>(thrust::atanh( c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x))); #else return static_cast>( std::atanh(static_cast>(x))); #endif } } // namespace c10_complex_math using c10_complex_math::acos; using c10_complex_math::acosh; using c10_complex_math::asin; using c10_complex_math::asinh; using c10_complex_math::atan; using c10_complex_math::atanh; using c10_complex_math::cos; using c10_complex_math::cosh; using c10_complex_math::exp; using c10_complex_math::log; using c10_complex_math::log10; using c10_complex_math::log2; using c10_complex_math::pow; using c10_complex_math::sin; using c10_complex_math::sinh; using c10_complex_math::sqrt; using c10_complex_math::tan; using c10_complex_math::tanh; namespace std { using c10_complex_math::acos; using c10_complex_math::acosh; using c10_complex_math::asin; using c10_complex_math::asinh; using c10_complex_math::atan; using c10_complex_math::atanh; using c10_complex_math::cos; using c10_complex_math::cosh; using c10_complex_math::exp; using c10_complex_math::log; using c10_complex_math::log10; using c10_complex_math::log2; using c10_complex_math::pow; using c10_complex_math::sin; using c10_complex_math::sinh; using c10_complex_math::sqrt; using c10_complex_math::tan; using c10_complex_math::tanh; } // namespace std