742 lines
18 KiB
C++
742 lines
18 KiB
C++
/*******************************************************************************
|
|
* Copyright (c) 2015-2018 Skymind, Inc.
|
|
*
|
|
* This program and the accompanying materials are made available under the
|
|
* terms of the Apache License, Version 2.0 which is available at
|
|
* https://www.apache.org/licenses/LICENSE-2.0.
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
******************************************************************************/
|
|
|
|
//
|
|
// @author raver119@gmail.com
|
|
//
|
|
|
|
#ifndef LIBND4J_PLATFORM_MATH_H
|
|
#define LIBND4J_PLATFORM_MATH_H
|
|
|
|
#include <math.h>
|
|
#include <cmath>
|
|
#include <op_boilerplate.h>
|
|
#include <types/types.h>
|
|
|
|
#ifdef __CUDACC__
|
|
#include <types/float16.h>
|
|
#include <types/bfloat16.h>
|
|
|
|
union BPAIR {
|
|
struct {
|
|
bfloat16 H;
|
|
bfloat16 L;
|
|
} B;
|
|
int W;
|
|
|
|
__host__ __device__
|
|
BPAIR() {};
|
|
|
|
__host__ __device__
|
|
~BPAIR() {};
|
|
};
|
|
|
|
#define math_def __host__ __device__
|
|
#ifdef CUDA_8
|
|
typedef union {
|
|
struct {
|
|
half H;
|
|
half L;
|
|
} B;
|
|
int W;
|
|
} PAIR;
|
|
#else
|
|
struct HALFS{
|
|
half H;
|
|
half L;
|
|
|
|
__host__ __device__
|
|
HALFS() {};
|
|
|
|
__host__ __device__
|
|
~HALFS() {};
|
|
};
|
|
union PAIR {
|
|
HALFS B;
|
|
int W;
|
|
|
|
__host__ __device__
|
|
PAIR() {};
|
|
|
|
__host__ __device__
|
|
~PAIR(){}
|
|
|
|
};
|
|
#endif // cuda_9
|
|
|
|
#else
|
|
#define math_def
|
|
#include <types/float16.h>
|
|
#endif
|
|
|
|
|
|
namespace nd4j {
|
|
namespace math {
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_exp(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_log(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_floor(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_ceil(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_round(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_cos(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_cosh(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_acos(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_acosh(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_sin(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_sinh(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_asin(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_sqrt(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_tanh(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_erf(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_erfc(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_atan(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_tan(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_atanh(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_rint(T value);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_remainder(T val1, T val2);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_fmod(T val1, T val2);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_pow(T value, T power);
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_atan2(T val1, T val2);
|
|
|
|
//////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_exp(float value) {
|
|
return expf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_exp(float16 val) {
|
|
#ifdef NATIVE_HALFS
|
|
return hexp(val.data);
|
|
#else
|
|
return static_cast<float16>(expf((float) val));
|
|
#endif
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_exp(bfloat16 val) {
|
|
return static_cast<bfloat16>(expf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_exp(double value) {
|
|
return exp(value);
|
|
}
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_exp(T value) {
|
|
return static_cast<T>(expf(static_cast<float>(value)));
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_pow(float16 value, float16 power) {
|
|
return static_cast<float16>(powf(static_cast<float>(value), static_cast<float>(power)));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_pow(bfloat16 value, bfloat16 power) {
|
|
return static_cast<bfloat16>(powf(static_cast<float>(value), static_cast<float>(power)));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_pow(float value, float power) {
|
|
return powf(value, power);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_pow(double value, double power) {
|
|
return pow(value, power);
|
|
}
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_pow(T value, T power) {
|
|
return static_cast<T>(powf(static_cast<float>(value), static_cast<float>(power)));
|
|
}
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_fmod(float16 value, float16 power) {
|
|
return static_cast<float16>(fmodf(static_cast<float>(value), static_cast<float>(power)));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_fmod(bfloat16 value, bfloat16 power) {
|
|
return static_cast<bfloat16>(fmodf(static_cast<float>(value), static_cast<float>(power)));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_fmod(float value, float power) {
|
|
return fmodf(value, power);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_fmod(double value, double power) {
|
|
return fmod(value, power);
|
|
}
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_fmod(T value, T power) {
|
|
return static_cast<T>(fmodf(static_cast<float>(value), static_cast<float>(power)));
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_atan2(float16 value, float16 power) {
|
|
return static_cast<float16>(atan2f(static_cast<float>(value), static_cast<float>(power)));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_atan2(float value, float power) {
|
|
return atan2f(value, power);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_atan2(double value, double power) {
|
|
return atan2(value, power);
|
|
}
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_atan2(T value, T power) {
|
|
return static_cast<T>(atan2f(static_cast<float>(value), static_cast<float>(power)));
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_remainder(float16 value, float16 power) {
|
|
return static_cast<float16>(remainderf(static_cast<float>(value), static_cast<float>(power)));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_remainder(float value, float power) {
|
|
return remainderf(value, power);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_remainder(double value, double power) {
|
|
return remainder(value, power);
|
|
}
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_remainder(T value, T power) {
|
|
return static_cast<T>(remainderf(static_cast<float>(value), static_cast<float>(power)));
|
|
}
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_log(float value) {
|
|
return logf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_log(float16 val) {
|
|
#ifdef NATIVE_HALFS
|
|
return hlog(val.data);
|
|
#else
|
|
return static_cast<float16>(logf((float) val));
|
|
#endif
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_log(double value) {
|
|
return log(value);
|
|
}
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_log(T value) {
|
|
return static_cast<T>(logf(static_cast<float>(value)));
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_floor(float value) {
|
|
return floorf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_floor(float16 val) {
|
|
#ifdef NATIVE_HALFS
|
|
return hfloor(val.data);
|
|
#else
|
|
return static_cast<float16>(floorf((float) val));
|
|
#endif
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_floor(double value) {
|
|
return floor(value);
|
|
}
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_floor(T value) {
|
|
return value;
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_ceil(float value) {
|
|
return ceilf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_ceil(float16 val) {
|
|
#ifdef NATIVE_HALFS
|
|
return hceil(val.data);
|
|
#else
|
|
return static_cast<float16>(ceilf((float) val));
|
|
#endif
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_ceil(double value) {
|
|
return ceil(value);
|
|
}
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_ceil(T value) {
|
|
return value;
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_round(float value) {
|
|
return roundf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_round(float16 val) {
|
|
return static_cast<float16>(roundf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_round(double value) {
|
|
return round(value);
|
|
}
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_round(T value) {
|
|
return value;
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_rint(float value) {
|
|
return rintf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_rint(float16 val) {
|
|
#ifdef NATIVE_HALFS
|
|
return hrint(val.data);
|
|
#else
|
|
return static_cast<float16>(rintf((float) val));
|
|
#endif
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_rint(bfloat16 val) {
|
|
return static_cast<bfloat16>(rintf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_rint(double value) {
|
|
return rint(value);
|
|
}
|
|
|
|
template <typename T>
|
|
math_def FORCEINLINE T p_rint(T value) {
|
|
return value;
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_cos(float value) {
|
|
return cosf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_cos(float16 val) {
|
|
#ifdef NATIVE_HALFS
|
|
return hcos(val.data);
|
|
#else
|
|
return static_cast<float16>(cosf((float) val));
|
|
#endif
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_cos(bfloat16 val) {
|
|
return static_cast<bfloat16>(cosf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_cos(double value) {
|
|
return cos(value);
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_sin(float value) {
|
|
return sinf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_sin(float16 val) {
|
|
#ifdef NATIVE_HALFS
|
|
return hsin(val.data);
|
|
#else
|
|
return static_cast<float16>(sinf((float) val));
|
|
#endif
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_sin(bfloat16 val) {
|
|
return static_cast<bfloat16>(sinf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_sin(double value) {
|
|
return sin(value);
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_sqrt(float value) {
|
|
return sqrtf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_sqrt(float16 val) {
|
|
#ifdef NATIVE_HALFS
|
|
return hsqrt(val.data);
|
|
#else
|
|
return static_cast<float16>(sqrtf((float) val));
|
|
#endif
|
|
}
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_sqrt(bfloat16 val) {
|
|
return static_cast<float16>(sqrtf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_sqrt(double value) {
|
|
return sqrt(value);
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_tanh(float value) {
|
|
return tanhf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_tanh(float16 val) {
|
|
return static_cast<float16>(tanhf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_tanh(bfloat16 val) {
|
|
return static_cast<bfloat16>(tanhf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_tanh(double value) {
|
|
return tanh(value);
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_erf(float value) {
|
|
return erff(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_erf(float16 val) {
|
|
return static_cast<float16>(erff((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_erf(bfloat16 val) {
|
|
return static_cast<bfloat16>(erff((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_erf(double value) {
|
|
return erf(value);
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_erfc(float value) {
|
|
return erfcf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_erfc(float16 val) {
|
|
return static_cast<float16>(erfcf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_erfc(bfloat16 val) {
|
|
return static_cast<bfloat16>(erfcf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_erfc(double value) {
|
|
return erfc(value);
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_acos(float value) {
|
|
return acosf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_acos(float16 val) {
|
|
return static_cast<float16>(acosf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_acos(bfloat16 val) {
|
|
return static_cast<bfloat16>(acosf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_acos(double value) {
|
|
return acos(value);
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_sinh(float value) {
|
|
return sinhf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_sinh(float16 val) {
|
|
return static_cast<float16>(sinhf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_sinh(bfloat16 val) {
|
|
return static_cast<bfloat16>(sinhf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_sinh(double value) {
|
|
return sinh(value);
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_acosh(float value) {
|
|
return acoshf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_acosh(float16 val) {
|
|
return static_cast<float16>(acoshf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_acosh(bfloat16 val) {
|
|
return static_cast<bfloat16>(acoshf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_acosh(double value) {
|
|
return acosh(value);
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_cosh(float value) {
|
|
return coshf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_cosh(float16 val) {
|
|
return static_cast<float16>(coshf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_cosh(bfloat16 val) {
|
|
return static_cast<bfloat16>(coshf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_cosh(double value) {
|
|
return cosh(value);
|
|
}
|
|
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_asin(float value) {
|
|
return asinf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_asin(float16 val) {
|
|
return static_cast<float16>(asinf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_asin(bfloat16 val) {
|
|
return static_cast<bfloat16>(asinf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_asin(double value) {
|
|
return asin(value);
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_atan(float value) {
|
|
return atanf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_atan(float16 val) {
|
|
return static_cast<float16>(atanf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_atan(bfloat16 val) {
|
|
return static_cast<bfloat16>(atanf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_atan(double value) {
|
|
return atan(value);
|
|
}
|
|
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_tan(float value) {
|
|
return tanf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_tan(float16 val) {
|
|
return static_cast<float16>(tanf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_tan(bfloat16 val) {
|
|
return static_cast<bfloat16>(tanf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_tan(double value) {
|
|
return tan(value);
|
|
}
|
|
|
|
/////////
|
|
|
|
template <>
|
|
math_def FORCEINLINE float p_atanh(float value) {
|
|
return atanhf(value);
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE float16 p_atanh(float16 val) {
|
|
return static_cast<float16>(atanhf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE bfloat16 p_atanh(bfloat16 val) {
|
|
return static_cast<bfloat16>(atanhf((float) val));
|
|
}
|
|
|
|
template <>
|
|
math_def FORCEINLINE double p_atanh(double value) {
|
|
return atanh(value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif //DEV_TESTS_PLATFORM_MATH_H
|