math Namespace Reference

math Namespace Reference#

Composable Kernel: ck::math Namespace Reference
Classes | Functions
ck::math Namespace Reference

Classes

struct  scales
struct  plus
struct  minus
struct  multiplies
struct  maximize
struct  minimize
struct  integer_divide_ceiler
struct  equal
struct  less

Functions

template<typename X, typename Y>
__host__ __device__ constexpr auto integer_divide_floor (X x, Y y)
template<typename X, typename Y>
__host__ __device__ constexpr auto integer_divide_ceil (X x, Y y)
template<typename X, typename Y>
__host__ __device__ constexpr auto integer_least_multiple (X x, Y y)
template<typename T>
__host__ __device__ constexpr T max (T x)
template<typename T>
__host__ __device__ constexpr T max (T x, T y)
template<index_t X>
__host__ __device__ constexpr index_t max (Number< X >, index_t y)
template<index_t Y>
__host__ __device__ constexpr index_t max (index_t x, Number< Y >)
template<typename X, typename... Ys>
__host__ __device__ constexpr auto max (X x, Ys... ys)
template<typename T>
__host__ __device__ constexpr T min (T x)
template<typename T>
__host__ __device__ constexpr T min (T x, T y)
template<index_t X>
__host__ __device__ constexpr index_t min (Number< X >, index_t y)
template<index_t Y>
__host__ __device__ constexpr index_t min (index_t x, Number< Y >)
template<typename X, typename... Ys>
__host__ __device__ constexpr auto min (X x, Ys... ys)
template<typename T>
__host__ __device__ constexpr T clamp (const T &x, const T &lowerbound, const T &upperbound)
__host__ __device__ constexpr index_t gcd (index_t x, index_t y)
template<index_t X, index_t Y>
__host__ __device__ constexpr auto gcd (Number< X >, Number< Y >)
template<typename X, typename... Ys, typename enable_if< sizeof...(Ys) > = 2, bool, ::type = false>
__host__ __device__ constexpr auto gcd (X x, Ys... ys)
template<typename X, typename Y>
__host__ __device__ constexpr auto lcm (X x, Y y)
template<typename X, typename... Ys, typename enable_if< sizeof...(Ys) > = 2, bool, ::type = false>
__host__ __device__ constexpr auto lcm (X x, Ys... ys)
template<index_t X>
__host__ __device__ constexpr auto next_power_of_two ()
template<index_t X>
__host__ __device__ constexpr auto next_power_of_two (Number< X > x)
template<typename T>
__host__ T tanh (T x)
template<>
__host__ float tanh< float > (float x)
template<>
__host__ double tanh< double > (double x)
template<typename T>
__host__ T acos (T x)
template<>
__host__ float acos< float > (float x)
template<>
__host__ double acos< double > (double x)
template<typename T>
__host__ T neg (T x)
template<>
__host__ float neg< float > (float x)
template<>
__host__ double neg< double > (double x)
template<>
__host__ int32_t neg< int32_t > (int32_t x)
template<>
__host__ int8_t neg< int8_t > (int8_t x)
template<typename T>
__host__ T atan (T x)
template<>
__host__ float atan< float > (float x)
template<>
__host__ double atan< double > (double x)
template<typename T>
__host__ T sin (T x)
template<>
__host__ float sin< float > (float x)
template<>
__host__ double sin< double > (double x)
template<typename T>
__host__ T asin (T x)
template<>
__host__ float asin< float > (float x)
template<>
__host__ double asin< double > (double x)
template<typename T>
__host__ T asinh (T x)
template<>
__host__ float asinh< float > (float x)
template<>
__host__ double asinh< double > (double x)
template<typename T>
__host__ T cos (T x)
template<>
__host__ float cos< float > (float x)
template<>
__host__ double cos< double > (double x)
template<typename T>
__host__ T acosh (T x)
template<>
__host__ float acosh< float > (float x)
template<>
__host__ double acosh< double > (double x)
template<typename T>
__host__ T tan (T x)
template<>
__host__ float tan< float > (float x)
template<>
__host__ double tan< double > (double x)
template<typename T>
__host__ T atanh (T x)
template<>
__host__ float atanh< float > (float x)
template<>
__host__ double atanh< double > (double x)
template<typename T>
__host__ T sinh (T x)
template<>
__host__ float sinh< float > (float x)
template<>
__host__ double sinh< double > (double x)
template<typename T>
__host__ T ceil (T x)
template<>
__host__ float ceil< float > (float x)
template<>
__host__ double ceil< double > (double x)
template<typename T>
__host__ T cosh (T x)
template<>
__host__ float cosh< float > (float x)
template<>
__host__ double cosh< double > (double x)
template<typename T>
__host__ T floor (T x)
template<>
__host__ float floor< float > (float x)
template<>
__host__ double floor< double > (double x)
template<typename T>
__host__ T rcp (T x)
template<typename T>
__host__ T exp (T x)
template<>
__host__ float exp< float > (float x)
template<>
__host__ double exp< double > (double x)
template<typename T>
__host__ T log (T x)
template<>
__host__ float log< float > (float x)
template<>
__host__ double log< double > (double x)
template<typename T>
__host__ T pow (T x, T gamma)
template<>
__host__ float pow< float > (float x, float gamma)
template<>
__host__ double pow< double > (double x, double gamma)
template<typename T>
__host__ T expm1 (T x)
template<>
__host__ float expm1< float > (float x)
template<>
__host__ double expm1< double > (double x)
template<typename T>
__device__ T tanh (T x)
template<>
__device__ float tanh< float > (float x)
template<>
__device__ double tanh< double > (double x)
template<typename T>
__device__ T acos (T x)
template<>
__device__ float acos< float > (float x)
template<>
__device__ double acos< double > (double x)
template<typename T>
__device__ T neg (T x)
template<>
__device__ float neg< float > (float x)
template<>
__device__ double neg< double > (double x)
template<>
__device__ int32_t neg< int32_t > (int32_t x)
template<>
__device__ int8_t neg< int8_t > (int8_t x)
template<>
__device__ half_t neg< half_t > (half_t x)
template<typename T>
__device__ T atan (T x)
template<>
__device__ float atan< float > (float x)
template<>
__device__ double atan< double > (double x)
template<typename T>
__device__ T sin (T x)
template<>
__device__ float sin< float > (float x)
template<>
__device__ double sin< double > (double x)
template<>
__device__ half_t sin< half_t > (half_t x)
template<typename T>
__device__ T asin (T x)
template<>
__device__ float asin< float > (float x)
template<>
__device__ double asin< double > (double x)
template<typename T>
__device__ T asinh (T x)
template<>
__device__ float asinh< float > (float x)
template<>
__device__ double asinh< double > (double x)
template<typename T>
__device__ T acosh (T x)
template<>
__device__ float acosh< float > (float x)
template<>
__device__ double acosh< double > (double x)
template<typename T>
__device__ T tan (T x)
template<>
__device__ float tan< float > (float x)
template<>
__device__ double tan< double > (double x)
template<typename T>
__device__ T atanh (T x)
template<>
__device__ float atanh< float > (float x)
template<>
__device__ double atanh< double > (double x)
template<typename T>
__device__ T sinh (T x)
template<>
__device__ float sinh< float > (float x)
template<>
__device__ double sinh< double > (double x)
template<typename T>
__device__ T ceil (T x)
template<>
__device__ float ceil< float > (float x)
template<>
__device__ double ceil< double > (double x)
template<>
__device__ half_t ceil< half_t > (half_t x)
template<typename T>
__device__ T cosh (T x)
template<>
__device__ float cosh< float > (float x)
template<>
__device__ double cosh< double > (double x)
template<typename T>
__device__ T floor (T x)
template<>
__device__ float floor< float > (float x)
template<>
__device__ double floor< double > (double x)
template<>
__device__ half_t floor< half_t > (half_t x)
template<typename T>
__device__ T rcp (T x)
template<typename T>
__device__ T exp (T x)
template<>
__device__ half_t exp< half_t > (half_t x)
template<>
__device__ float exp< float > (float x)
template<>
__device__ double exp< double > (double x)
template<typename T>
__device__ T log (T x)
template<>
__device__ half_t log< half_t > (half_t x)
template<>
__device__ float log< float > (float x)
template<>
__device__ double log< double > (double x)
template<typename T>
__device__ T pow (T x, T gamma)
template<>
__device__ float pow< float > (float x, float gamma)
template<>
__device__ double pow< double > (double x, double gamma)
template<typename T>
__device__ T expm1 (T x)
template<>
__device__ float expm1< float > (float x)
template<>
__device__ double expm1< double > (double x)
template<typename T>
__device__ T cos (T x)
template<>
__device__ float cos< float > (float x)
template<>
__device__ double cos< double > (double x)

Function Documentation

◆ acos() [1/2]

template<typename T>
__device__ T ck::math::acos ( T x)
inline

◆ acos() [2/2]

template<typename T>
__host__ T ck::math::acos ( T x)
inline

◆ acos< double >() [1/2]

template<>
__device__ double ck::math::acos< double > ( double x)
inline

◆ acos< double >() [2/2]

template<>
__host__ double ck::math::acos< double > ( double x)
inline

◆ acos< float >() [1/2]

template<>
__device__ float ck::math::acos< float > ( float x)
inline

◆ acos< float >() [2/2]

template<>
__host__ float ck::math::acos< float > ( float x)
inline

◆ acosh() [1/2]

template<typename T>
__device__ T ck::math::acosh ( T x)
inline

◆ acosh() [2/2]

template<typename T>
__host__ T ck::math::acosh ( T x)
inline

◆ acosh< double >() [1/2]

template<>
__device__ double ck::math::acosh< double > ( double x)
inline

◆ acosh< double >() [2/2]

template<>
__host__ double ck::math::acosh< double > ( double x)
inline

◆ acosh< float >() [1/2]

template<>
__device__ float ck::math::acosh< float > ( float x)
inline

◆ acosh< float >() [2/2]

template<>
__host__ float ck::math::acosh< float > ( float x)
inline

◆ asin() [1/2]

template<typename T>
__device__ T ck::math::asin ( T x)
inline

◆ asin() [2/2]

template<typename T>
__host__ T ck::math::asin ( T x)
inline

◆ asin< double >() [1/2]

template<>
__device__ double ck::math::asin< double > ( double x)
inline

◆ asin< double >() [2/2]

template<>
__host__ double ck::math::asin< double > ( double x)
inline

◆ asin< float >() [1/2]

template<>
__device__ float ck::math::asin< float > ( float x)
inline

◆ asin< float >() [2/2]

template<>
__host__ float ck::math::asin< float > ( float x)
inline

◆ asinh() [1/2]

template<typename T>
__device__ T ck::math::asinh ( T x)
inline

◆ asinh() [2/2]

template<typename T>
__host__ T ck::math::asinh ( T x)
inline

◆ asinh< double >() [1/2]

template<>
__device__ double ck::math::asinh< double > ( double x)
inline

◆ asinh< double >() [2/2]

template<>
__host__ double ck::math::asinh< double > ( double x)
inline

◆ asinh< float >() [1/2]

template<>
__device__ float ck::math::asinh< float > ( float x)
inline

◆ asinh< float >() [2/2]

template<>
__host__ float ck::math::asinh< float > ( float x)
inline

◆ atan() [1/2]

template<typename T>
__device__ T ck::math::atan ( T x)
inline

◆ atan() [2/2]

template<typename T>
__host__ T ck::math::atan ( T x)
inline

◆ atan< double >() [1/2]

template<>
__device__ double ck::math::atan< double > ( double x)
inline

◆ atan< double >() [2/2]

template<>
__host__ double ck::math::atan< double > ( double x)
inline

◆ atan< float >() [1/2]

template<>
__device__ float ck::math::atan< float > ( float x)
inline

◆ atan< float >() [2/2]

template<>
__host__ float ck::math::atan< float > ( float x)
inline

◆ atanh() [1/2]

template<typename T>
__device__ T ck::math::atanh ( T x)
inline

◆ atanh() [2/2]

template<typename T>
__host__ T ck::math::atanh ( T x)
inline

◆ atanh< double >() [1/2]

template<>
__device__ double ck::math::atanh< double > ( double x)
inline

◆ atanh< double >() [2/2]

template<>
__host__ double ck::math::atanh< double > ( double x)
inline

◆ atanh< float >() [1/2]

template<>
__device__ float ck::math::atanh< float > ( float x)
inline

◆ atanh< float >() [2/2]

template<>
__host__ float ck::math::atanh< float > ( float x)
inline

◆ ceil() [1/2]

template<typename T>
__device__ T ck::math::ceil ( T x)
inline

◆ ceil() [2/2]

template<typename T>
__host__ T ck::math::ceil ( T x)
inline

◆ ceil< double >() [1/2]

template<>
__device__ double ck::math::ceil< double > ( double x)
inline

◆ ceil< double >() [2/2]

template<>
__host__ double ck::math::ceil< double > ( double x)
inline

◆ ceil< float >() [1/2]

template<>
__device__ float ck::math::ceil< float > ( float x)
inline

◆ ceil< float >() [2/2]

template<>
__host__ float ck::math::ceil< float > ( float x)
inline

◆ ceil< half_t >()

template<>
__device__ half_t ck::math::ceil< half_t > ( half_t x)
inline

◆ clamp()

template<typename T>
__host__ __device__ constexpr T ck::math::clamp ( const T & x,
const T & lowerbound,
const T & upperbound )
constexpr

◆ cos() [1/2]

template<typename T>
__device__ T ck::math::cos ( T x)
inline

◆ cos() [2/2]

template<typename T>
__host__ T ck::math::cos ( T x)
inline

◆ cos< double >() [1/2]

template<>
__device__ double ck::math::cos< double > ( double x)
inline

◆ cos< double >() [2/2]

template<>
__host__ double ck::math::cos< double > ( double x)
inline

◆ cos< float >() [1/2]

template<>
__device__ float ck::math::cos< float > ( float x)
inline

◆ cos< float >() [2/2]

template<>
__host__ float ck::math::cos< float > ( float x)
inline

◆ cosh() [1/2]

template<typename T>
__device__ T ck::math::cosh ( T x)
inline

◆ cosh() [2/2]

template<typename T>
__host__ T ck::math::cosh ( T x)
inline

◆ cosh< double >() [1/2]

template<>
__device__ double ck::math::cosh< double > ( double x)
inline

◆ cosh< double >() [2/2]

template<>
__host__ double ck::math::cosh< double > ( double x)
inline

◆ cosh< float >() [1/2]

template<>
__device__ float ck::math::cosh< float > ( float x)
inline

◆ cosh< float >() [2/2]

template<>
__host__ float ck::math::cosh< float > ( float x)
inline

◆ exp() [1/2]

template<typename T>
__device__ T ck::math::exp ( T x)
inline

◆ exp() [2/2]

template<typename T>
__host__ T ck::math::exp ( T x)
inline

◆ exp< double >() [1/2]

template<>
__device__ double ck::math::exp< double > ( double x)
inline

◆ exp< double >() [2/2]

template<>
__host__ double ck::math::exp< double > ( double x)
inline

◆ exp< float >() [1/2]

template<>
__device__ float ck::math::exp< float > ( float x)
inline

◆ exp< float >() [2/2]

template<>
__host__ float ck::math::exp< float > ( float x)
inline

◆ exp< half_t >()

template<>
__device__ half_t ck::math::exp< half_t > ( half_t x)
inline

◆ expm1() [1/2]

template<typename T>
__device__ T ck::math::expm1 ( T x)
inline

◆ expm1() [2/2]

template<typename T>
__host__ T ck::math::expm1 ( T x)
inline

◆ expm1< double >() [1/2]

template<>
__device__ double ck::math::expm1< double > ( double x)
inline

◆ expm1< double >() [2/2]

template<>
__host__ double ck::math::expm1< double > ( double x)
inline

◆ expm1< float >() [1/2]

template<>
__device__ float ck::math::expm1< float > ( float x)
inline

◆ expm1< float >() [2/2]

template<>
__host__ float ck::math::expm1< float > ( float x)
inline

◆ floor() [1/2]

template<typename T>
__device__ T ck::math::floor ( T x)
inline

◆ floor() [2/2]

template<typename T>
__host__ T ck::math::floor ( T x)
inline

◆ floor< double >() [1/2]

template<>
__device__ double ck::math::floor< double > ( double x)
inline

◆ floor< double >() [2/2]

template<>
__host__ double ck::math::floor< double > ( double x)
inline

◆ floor< float >() [1/2]

template<>
__device__ float ck::math::floor< float > ( float x)
inline

◆ floor< float >() [2/2]

template<>
__host__ float ck::math::floor< float > ( float x)
inline

◆ floor< half_t >()

template<>
__device__ half_t ck::math::floor< half_t > ( half_t x)
inline

◆ gcd() [1/3]

__host__ __device__ constexpr index_t ck::math::gcd ( index_t x,
index_t y )
constexpr

◆ gcd() [2/3]

template<index_t X, index_t Y>
__host__ __device__ constexpr auto ck::math::gcd ( Number< X > ,
Number< Y >  )
constexpr

◆ gcd() [3/3]

template<typename X, typename... Ys, typename enable_if< sizeof...(Ys) > = 2, bool, ::type = false>
__host__ __device__ constexpr auto ck::math::gcd ( X x,
Ys... ys )
constexpr

◆ integer_divide_ceil()

template<typename X, typename Y>
__host__ __device__ constexpr auto ck::math::integer_divide_ceil ( X x,
Y y )
constexpr

◆ integer_divide_floor()

template<typename X, typename Y>
__host__ __device__ constexpr auto ck::math::integer_divide_floor ( X x,
Y y )
constexpr

◆ integer_least_multiple()

template<typename X, typename Y>
__host__ __device__ constexpr auto ck::math::integer_least_multiple ( X x,
Y y )
constexpr

◆ lcm() [1/2]

template<typename X, typename Y>
__host__ __device__ constexpr auto ck::math::lcm ( X x,
Y y )
constexpr

◆ lcm() [2/2]

template<typename X, typename... Ys, typename enable_if< sizeof...(Ys) > = 2, bool, ::type = false>
__host__ __device__ constexpr auto ck::math::lcm ( X x,
Ys... ys )
constexpr

◆ log() [1/2]

template<typename T>
__device__ T ck::math::log ( T x)
inline

◆ log() [2/2]

template<typename T>
__host__ T ck::math::log ( T x)
inline

◆ log< double >() [1/2]

template<>
__device__ double ck::math::log< double > ( double x)
inline

◆ log< double >() [2/2]

template<>
__host__ double ck::math::log< double > ( double x)
inline

◆ log< float >() [1/2]

template<>
__device__ float ck::math::log< float > ( float x)
inline

◆ log< float >() [2/2]

template<>
__host__ float ck::math::log< float > ( float x)
inline

◆ log< half_t >()

template<>
__device__ half_t ck::math::log< half_t > ( half_t x)
inline

◆ max() [1/5]

template<index_t Y>
__host__ __device__ constexpr index_t ck::math::max ( index_t x,
Number< Y >  )
constexpr

◆ max() [2/5]

template<index_t X>
__host__ __device__ constexpr index_t ck::math::max ( Number< X > ,
index_t y )
constexpr

◆ max() [3/5]

template<typename T>
__host__ __device__ constexpr T ck::math::max ( T x)
constexpr

◆ max() [4/5]

template<typename T>
__host__ __device__ constexpr T ck::math::max ( T x,
T y )
constexpr

◆ max() [5/5]

template<typename X, typename... Ys>
__host__ __device__ constexpr auto ck::math::max ( X x,
Ys... ys )
constexpr

◆ min() [1/5]

template<index_t Y>
__host__ __device__ constexpr index_t ck::math::min ( index_t x,
Number< Y >  )
constexpr

◆ min() [2/5]

template<index_t X>
__host__ __device__ constexpr index_t ck::math::min ( Number< X > ,
index_t y )
constexpr

◆ min() [3/5]

template<typename T>
__host__ __device__ constexpr T ck::math::min ( T x)
constexpr

◆ min() [4/5]

template<typename T>
__host__ __device__ constexpr T ck::math::min ( T x,
T y )
constexpr

◆ min() [5/5]

template<typename X, typename... Ys>
__host__ __device__ constexpr auto ck::math::min ( X x,
Ys... ys )
constexpr

◆ neg() [1/2]

template<typename T>
__device__ T ck::math::neg ( T x)
inline

◆ neg() [2/2]

template<typename T>
__host__ T ck::math::neg ( T x)
inline

◆ neg< double >() [1/2]

template<>
__device__ double ck::math::neg< double > ( double x)
inline

◆ neg< double >() [2/2]

template<>
__host__ double ck::math::neg< double > ( double x)
inline

◆ neg< float >() [1/2]

template<>
__device__ float ck::math::neg< float > ( float x)
inline

◆ neg< float >() [2/2]

template<>
__host__ float ck::math::neg< float > ( float x)
inline

◆ neg< half_t >()

template<>
__device__ half_t ck::math::neg< half_t > ( half_t x)
inline

◆ neg< int32_t >() [1/2]

template<>
__device__ int32_t ck::math::neg< int32_t > ( int32_t x)
inline

◆ neg< int32_t >() [2/2]

template<>
__host__ int32_t ck::math::neg< int32_t > ( int32_t x)
inline

◆ neg< int8_t >() [1/2]

template<>
__device__ int8_t ck::math::neg< int8_t > ( int8_t x)
inline

◆ neg< int8_t >() [2/2]

template<>
__host__ int8_t ck::math::neg< int8_t > ( int8_t x)
inline

◆ next_power_of_two() [1/2]

template<index_t X>
__host__ __device__ constexpr auto ck::math::next_power_of_two ( )
constexpr

◆ next_power_of_two() [2/2]

template<index_t X>
__host__ __device__ constexpr auto ck::math::next_power_of_two ( Number< X > x)
constexpr

◆ pow() [1/2]

template<typename T>
__device__ T ck::math::pow ( T x,
T gamma )
inline

◆ pow() [2/2]

template<typename T>
__host__ T ck::math::pow ( T x,
T gamma )
inline

◆ pow< double >() [1/2]

template<>
__device__ double ck::math::pow< double > ( double x,
double gamma )
inline

◆ pow< double >() [2/2]

template<>
__host__ double ck::math::pow< double > ( double x,
double gamma )
inline

◆ pow< float >() [1/2]

template<>
__device__ float ck::math::pow< float > ( float x,
float gamma )
inline

◆ pow< float >() [2/2]

template<>
__host__ float ck::math::pow< float > ( float x,
float gamma )
inline

◆ rcp() [1/2]

template<typename T>
__device__ T ck::math::rcp ( T x)
inline

◆ rcp() [2/2]

template<typename T>
__host__ T ck::math::rcp ( T x)
inline

◆ sin() [1/2]

template<typename T>
__device__ T ck::math::sin ( T x)
inline

◆ sin() [2/2]

template<typename T>
__host__ T ck::math::sin ( T x)
inline

◆ sin< double >() [1/2]

template<>
__device__ double ck::math::sin< double > ( double x)
inline

◆ sin< double >() [2/2]

template<>
__host__ double ck::math::sin< double > ( double x)
inline

◆ sin< float >() [1/2]

template<>
__device__ float ck::math::sin< float > ( float x)
inline

◆ sin< float >() [2/2]

template<>
__host__ float ck::math::sin< float > ( float x)
inline

◆ sin< half_t >()

template<>
__device__ half_t ck::math::sin< half_t > ( half_t x)
inline

◆ sinh() [1/2]

template<typename T>
__device__ T ck::math::sinh ( T x)
inline

◆ sinh() [2/2]

template<typename T>
__host__ T ck::math::sinh ( T x)
inline

◆ sinh< double >() [1/2]

template<>
__device__ double ck::math::sinh< double > ( double x)
inline

◆ sinh< double >() [2/2]

template<>
__host__ double ck::math::sinh< double > ( double x)
inline

◆ sinh< float >() [1/2]

template<>
__device__ float ck::math::sinh< float > ( float x)
inline

◆ sinh< float >() [2/2]

template<>
__host__ float ck::math::sinh< float > ( float x)
inline

◆ tan() [1/2]

template<typename T>
__device__ T ck::math::tan ( T x)
inline

◆ tan() [2/2]

template<typename T>
__host__ T ck::math::tan ( T x)
inline

◆ tan< double >() [1/2]

template<>
__device__ double ck::math::tan< double > ( double x)
inline

◆ tan< double >() [2/2]

template<>
__host__ double ck::math::tan< double > ( double x)
inline

◆ tan< float >() [1/2]

template<>
__device__ float ck::math::tan< float > ( float x)
inline

◆ tan< float >() [2/2]

template<>
__host__ float ck::math::tan< float > ( float x)
inline

◆ tanh() [1/2]

template<typename T>
__device__ T ck::math::tanh ( T x)
inline

◆ tanh() [2/2]

template<typename T>
__host__ T ck::math::tanh ( T x)
inline

◆ tanh< double >() [1/2]

template<>
__device__ double ck::math::tanh< double > ( double x)
inline

◆ tanh< double >() [2/2]

template<>
__host__ double ck::math::tanh< double > ( double x)
inline

◆ tanh< float >() [1/2]

template<>
__device__ float ck::math::tanh< float > ( float x)
inline

◆ tanh< float >() [2/2]

template<>
__host__ float ck::math::tanh< float > ( float x)
inline