Permalink
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
13023 lines (12538 sloc) 898 KB
//
// SPIR Tools
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
#ifndef _OPENCL_H_
#define _OPENCL_H_
#if !defined(__SPIR32__) && !defined(__SPIR64__)
#error "This header file should be used with SPIR target only."
#endif
// Optimizations
#define const_func __attribute__((const))
#define readonly __attribute__((pure))
// built-in scalar data types:
/**
* An unsigned 8-bit integer.
*/
typedef unsigned char uchar;
/**
* An unsigned 16-bit integer.
*/
typedef unsigned short ushort;
/**
* An unsigned 32-bit integer.
*/
typedef unsigned int uint;
/**
* An unsigned 64-bit integer.
*/
typedef unsigned long ulong;
/**
* The unsigned integer type of the result of the sizeof operator. This
* is a 32-bit unsigned integer if CL_DEVICE_ADDRESS_BITS
* defined in table 4.3 is 32-bits and is a 64-bit unsigned integer if
* CL_DEVICE_ADDRESS_BITS is 64-bits.
*/
#if defined(__SPIR32__)
typedef uint size_t;
#elif defined (__SPIR64__)
typedef ulong size_t;
#endif
/**
* A signed integer type that is the result of subtracting two pointers.
* This is a 32-bit signed integer if CL_DEVICE_ADDRESS_BITS
* defined in table 4.3 is 32-bits and is a 64-bit signed integer if
* CL_DEVICE_ADDRESS_BITS is 64-bits.
*/
#if defined(__SPIR32__)
typedef int ptrdiff_t;
#elif defined (__SPIR64__ )
typedef long ptrdiff_t;
#endif
typedef ptrdiff_t intptr_t;
typedef size_t uintptr_t;
// built-in vector data types:
typedef char char2 __attribute__((ext_vector_type(2)));
typedef char char3 __attribute__((ext_vector_type(3)));
typedef char char4 __attribute__((ext_vector_type(4)));
typedef char char8 __attribute__((ext_vector_type(8)));
typedef char char16 __attribute__((ext_vector_type(16)));
typedef uchar uchar2 __attribute__((ext_vector_type(2)));
typedef uchar uchar3 __attribute__((ext_vector_type(3)));
typedef uchar uchar4 __attribute__((ext_vector_type(4)));
typedef uchar uchar8 __attribute__((ext_vector_type(8)));
typedef uchar uchar16 __attribute__((ext_vector_type(16)));
typedef short short2 __attribute__((ext_vector_type(2)));
typedef short short3 __attribute__((ext_vector_type(3)));
typedef short short4 __attribute__((ext_vector_type(4)));
typedef short short8 __attribute__((ext_vector_type(8)));
typedef short short16 __attribute__((ext_vector_type(16)));
typedef ushort ushort2 __attribute__((ext_vector_type(2)));
typedef ushort ushort3 __attribute__((ext_vector_type(3)));
typedef ushort ushort4 __attribute__((ext_vector_type(4)));
typedef ushort ushort8 __attribute__((ext_vector_type(8)));
typedef ushort ushort16 __attribute__((ext_vector_type(16)));
typedef int int2 __attribute__((ext_vector_type(2)));
typedef int int3 __attribute__((ext_vector_type(3)));
typedef int int4 __attribute__((ext_vector_type(4)));
typedef int int8 __attribute__((ext_vector_type(8)));
typedef int int16 __attribute__((ext_vector_type(16)));
typedef uint uint2 __attribute__((ext_vector_type(2)));
typedef uint uint3 __attribute__((ext_vector_type(3)));
typedef uint uint4 __attribute__((ext_vector_type(4)));
typedef uint uint8 __attribute__((ext_vector_type(8)));
typedef uint uint16 __attribute__((ext_vector_type(16)));
typedef long long2 __attribute__((ext_vector_type(2)));
typedef long long3 __attribute__((ext_vector_type(3)));
typedef long long4 __attribute__((ext_vector_type(4)));
typedef long long8 __attribute__((ext_vector_type(8)));
typedef long long16 __attribute__((ext_vector_type(16)));
typedef ulong ulong2 __attribute__((ext_vector_type(2)));
typedef ulong ulong3 __attribute__((ext_vector_type(3)));
typedef ulong ulong4 __attribute__((ext_vector_type(4)));
typedef ulong ulong8 __attribute__((ext_vector_type(8)));
typedef ulong ulong16 __attribute__((ext_vector_type(16)));
typedef float float2 __attribute__((ext_vector_type(2)));
typedef float float3 __attribute__((ext_vector_type(3)));
typedef float float4 __attribute__((ext_vector_type(4)));
typedef float float8 __attribute__((ext_vector_type(8)));
typedef float float16 __attribute__((ext_vector_type(16)));
typedef half half2 __attribute__((ext_vector_type(2)));
typedef half half3 __attribute__((ext_vector_type(3)));
typedef half half4 __attribute__((ext_vector_type(4)));
typedef half half8 __attribute__((ext_vector_type(8)));
typedef half half16 __attribute__((ext_vector_type(16)));
typedef double double2 __attribute__((ext_vector_type(2)));
typedef double double3 __attribute__((ext_vector_type(3)));
typedef double double4 __attribute__((ext_vector_type(4)));
typedef double double8 __attribute__((ext_vector_type(8)));
typedef double double16 __attribute__((ext_vector_type(16)));
/**
* Value of maximum non-infinite single-precision floating-point
* number.
*/
#define MAXFLOAT 0x1.fffffep127f
/**
* A positive float constant expression. HUGE_VALF evaluates
* to +infinity. Used as an error value returned by the built-in
* math functions.
*/
#define HUGE_VALF (__builtin_huge_valf())
/**
* A positive double constant expression. HUGE_VAL evaluates
* to +infinity. Used as an error value returned by the built-in
* math functions.
*/
#define HUGE_VAL (__builtin_huge_val())
/**
* A constant expression of type float representing positive or
* unsigned infinity.
*/
#define INFINITY (__builtin_inff())
/**
* A constant expression of type float representing a quiet NaN.
*/
#define NAN as_float(__builtin_nanf((char const *)""))
#define FP_ILOGB0 INT_MIN
#define FP_ILOGBNAN INT_MAX
#define FLT_DIG 6
#define FLT_MANT_DIG 24
#define FLT_MAX_10_EXP +38
#define FLT_MAX_EXP +128
#define FLT_MIN_10_EXP -37
#define FLT_MIN_EXP -125
#define FLT_RADIX 2
#define FLT_MAX 0x1.fffffep127f
#define FLT_MIN 0x1.0p-126f
#define FLT_EPSILON 0x1.0p-23f
#define DBL_DIG 15
#define DBL_MANT_DIG 53
#define DBL_MAX_10_EXP +308
#define DBL_MAX_EXP +1024
#define DBL_MIN_10_EXP -307
#define DBL_MIN_EXP -1021
#define DBL_RADIX 2
#define DBL_MAX 0x1.fffffffffffffp1023
#define DBL_MIN 0x1.0p-1022
#define DBL_EPSILON 0x1.0p-52
#define M_E_F 2.71828182845904523536028747135266250f
#define M_LOG2E_F 1.44269504088896340735992468100189214f
#define M_LOG10E_F 0.434294481903251827651128918916605082f
#define M_LN2_F 0.693147180559945309417232121458176568f
#define M_LN10_F 2.30258509299404568401799145468436421f
#define M_PI_F 3.14159265358979323846264338327950288f
#define M_PI_2_F 1.57079632679489661923132169163975144f
#define M_PI_4_F 0.785398163397448309615660845819875721f
#define M_1_PI_F 0.318309886183790671537767526745028724f
#define M_2_PI_F 0.636619772367581343075535053490057448f
#define M_2_SQRTPI_F 1.12837916709551257389615890312154517f
#define M_SQRT2_F 1.41421356237309504880168872420969808f
#define M_SQRT1_2_F 0.707106781186547524400844362104849039f
#define M_E 0x1.5bf0a8b145769p+1
#define M_LOG2E 0x1.71547652b82fep+0
#define M_LOG10E 0x1.bcb7b1526e50ep-2
#define M_LN2 0x1.62e42fefa39efp-1
#define M_LN10 0x1.26bb1bbb55516p+1
#define M_PI 0x1.921fb54442d18p+1
#define M_PI_2 0x1.921fb54442d18p+0
#define M_PI_4 0x1.921fb54442d18p-1
#define M_1_PI 0x1.45f306dc9c883p-2
#define M_2_PI 0x1.45f306dc9c883p-1
#define M_2_SQRTPI 0x1.20dd750429b6dp+0
#define M_SQRT2 0x1.6a09e667f3bcdp+0
#define M_SQRT1_2 0x1.6a09e667f3bcdp-1
#define CHAR_BIT 8
#define SCHAR_MAX 127
#define SCHAR_MIN (-128)
#define UCHAR_MAX 255
#define CHAR_MAX SCHAR_MAX
#define CHAR_MIN SCHAR_MIN
#define USHRT_MAX 65535
#define SHRT_MAX 32767
#define SHRT_MIN (-32768)
#define UINT_MAX 0xffffffff
#define INT_MAX 2147483647
#define INT_MIN (-2147483647-1)
#define ULONG_MAX 0xffffffffffffffffUL
#define LONG_MAX ((long)0x7fffffffffffffffL)
#define LONG_MIN ((long)(-0x7fffffffffffffffL-1))
#define DBL_DIG 15
#define DBL_MANT_DIG 53
#define DBL_MAX_10_EXP +308
#define DBL_MAX_EXP +1024
#define DBL_MIN_10_EXP -307
#define DBL_MIN_EXP -1021
#define DBL_MAX 0x1.fffffffffffffp1023
#define DBL_MIN 0x1.0p-1022
#define DBL_EPSILON 0x1.0p-52
// work-item functions
/**
* Returns the number of dimensions in use. This is the
* value given to the work_dim argument specified in
* clEnqueueNDRangeKernel.
* For clEnqueueTask, this returns 1.
*/
uint const_func __attribute__((overloadable)) get_work_dim(void);
/**
* Returns the number of global work-items specified for
* dimension identified by dimindx. This value is given by
* the global_work_size argument to
* clEnqueueNDRangeKernel. Valid values of dimindx
* are 0 to get_work_dim() – 1. For other values of
* dimindx, get_global_size() returns 1.
* For clEnqueueTask, this always returns 1.
*/
size_t const_func __attribute__((overloadable)) get_global_size(uint dimindx);
/**
* Returns the unique global work-item ID value for
* dimension identified by dimindx. The global work-item
* ID specifies the work-item ID based on the number of
* global work-items specified to execute the kernel. Valid
* values of dimindx are 0 to get_work_dim() – 1. For
* other values of dimindx, get_global_id() returns 0.
* For clEnqueueTask, this returns 0.
*/
size_t const_func __attribute__((overloadable)) get_global_id(uint dimindx);
/**
* Returns the number of local work-items specified in
* dimension identified by dimindx. This value is given by
* the local_work_size argument to
* clEnqueueNDRangeKernel if local_work_size is not
* NULL; otherwise the OpenCL implementation chooses
* an appropriate local_work_size value which is returned
* by this function. Valid values of dimindx are 0 to
* get_work_dim() – 1. For other values of dimindx,
* get_local_size() returns 1.
* For clEnqueueTask, this always returns 1.
*/
size_t const_func __attribute__((overloadable)) get_local_size(uint dimindx);
/**
* Returns the unique local work-item ID i.e. a work-item
* within a specific work-group for dimension identified by
* dimindx. Valid values of dimindx are 0 to
* get_work_dim() – 1. For other values of dimindx,
* get_local_id() returns 0.
* For clEnqueueTask, this returns 0.
*/
size_t const_func __attribute__((overloadable)) get_local_id(uint dimindx);
/**
* Returns the number of work-groups that will execute a
* kernel for dimension identified by dimindx.
* Valid values of dimindx are 0 to get_work_dim() – 1.
* For other values of dimindx, get_num_groups () returns
* 1.
* For clEnqueueTask, this always returns 1.
*/
size_t const_func __attribute__((overloadable)) get_num_groups(uint dimindx);
/**
* get_group_id returns the work-group ID which is a
* number from 0 .. get_num_groups(dimindx) – 1.
* Valid values of dimindx are 0 to get_work_dim() – 1.
* For other values, get_group_id() returns 0.
* For clEnqueueTask, this returns 0.
*/
size_t const_func __attribute__((overloadable)) get_group_id(uint dimindx);
/**
* get_global_offset returns the offset values specified in
* global_work_offset argument to
* clEnqueueNDRangeKernel.
* Valid values of dimindx are 0 to get_work_dim() – 1.
* For other values, get_global_offset() returns 0.
* For clEnqueueTask, this returns 0.
*/
size_t const_func __attribute__((overloadable)) get_global_offset(uint dimindx);
int printf(__constant const char* st, ...);
// Math functions:
/**
* Arc cosine function.
*/
float const_func __attribute__((overloadable)) acos(float);
float2 const_func __attribute__((overloadable)) acos(float2);
float3 const_func __attribute__((overloadable)) acos(float3);
float4 const_func __attribute__((overloadable)) acos(float4);
float8 const_func __attribute__((overloadable)) acos(float8);
float16 const_func __attribute__((overloadable)) acos(float16);
double const_func __attribute__((overloadable)) acos(double);
double2 const_func __attribute__((overloadable)) acos(double2);
double3 const_func __attribute__((overloadable)) acos(double3);
double4 const_func __attribute__((overloadable)) acos(double4);
double8 const_func __attribute__((overloadable)) acos(double8);
double16 const_func __attribute__((overloadable)) acos(double16);
//half const_func __attribute__((overloadable)) acos(half);
//half2 const_func __attribute__((overloadable)) acos(half2);
//half3 const_func __attribute__((overloadable)) acos(half3);
//half4 const_func __attribute__((overloadable)) acos(half4);
//half8 const_func __attribute__((overloadable)) acos(half8);
//half16 const_func __attribute__((overloadable)) acos(half16);
/**
* Inverse hyperbolic cosine.
*/
float const_func __attribute__((overloadable)) acosh(float);
float2 const_func __attribute__((overloadable)) acosh(float2);
float3 const_func __attribute__((overloadable)) acosh(float3);
float4 const_func __attribute__((overloadable)) acosh(float4);
float8 const_func __attribute__((overloadable)) acosh(float8);
float16 const_func __attribute__((overloadable)) acosh(float16);
double const_func __attribute__((overloadable)) acosh(double);
double2 const_func __attribute__((overloadable)) acosh(double2);
double3 const_func __attribute__((overloadable)) acosh(double3);
double4 const_func __attribute__((overloadable)) acosh(double4);
double8 const_func __attribute__((overloadable)) acosh(double8);
double16 const_func __attribute__((overloadable)) acosh(double16);
//half const_func __attribute__((overloadable)) acosh(half);
//half2 const_func __attribute__((overloadable)) acosh(half2);
//half3 const_func __attribute__((overloadable)) acosh(half3);
//half4 const_func __attribute__((overloadable)) acosh(half4);
//half8 const_func __attribute__((overloadable)) acosh(half8);
//half16 const_func __attribute__((overloadable)) acosh(half16);
/**
* Compute acos (x) / PI.
*/
float const_func __attribute__((overloadable)) acospi(float x);
float2 const_func __attribute__((overloadable)) acospi(float2 x);
float3 const_func __attribute__((overloadable)) acospi(float3 x);
float4 const_func __attribute__((overloadable)) acospi(float4 x);
float8 const_func __attribute__((overloadable)) acospi(float8 x);
float16 const_func __attribute__((overloadable)) acospi(float16 x);
double const_func __attribute__((overloadable)) acospi(double x);
double2 const_func __attribute__((overloadable)) acospi(double2 x);
double3 const_func __attribute__((overloadable)) acospi(double3 x);
double4 const_func __attribute__((overloadable)) acospi(double4 x);
double8 const_func __attribute__((overloadable)) acospi(double8 x);
double16 const_func __attribute__((overloadable)) acospi(double16 x);
//half const_func __attribute__((overloadable)) acospi(half x);
//half2 const_func __attribute__((overloadable)) acospi(half2 x);
//half3 const_func __attribute__((overloadable)) acospi(half3 x);
//half4 const_func __attribute__((overloadable)) acospi(half4 x);
//half8 const_func __attribute__((overloadable)) acospi(half8 x);
//half16 const_func __attribute__((overloadable)) acospi(half16 x);
/**
* Arc sine function.
*/
float const_func __attribute__((overloadable)) asin(float);
float2 const_func __attribute__((overloadable)) asin(float2);
float3 const_func __attribute__((overloadable)) asin(float3);
float4 const_func __attribute__((overloadable)) asin(float4);
float8 const_func __attribute__((overloadable)) asin(float8);
float16 const_func __attribute__((overloadable)) asin(float16);
double const_func __attribute__((overloadable)) asin(double);
double2 const_func __attribute__((overloadable)) asin(double2);
double3 const_func __attribute__((overloadable)) asin(double3);
double4 const_func __attribute__((overloadable)) asin(double4);
double8 const_func __attribute__((overloadable)) asin(double8);
double16 const_func __attribute__((overloadable)) asin(double16);
//half const_func __attribute__((overloadable)) asin(half);
//half2 const_func __attribute__((overloadable)) asin(half2);
//half3 const_func __attribute__((overloadable)) asin(half3);
//half4 const_func __attribute__((overloadable)) asin(half4);
//half8 const_func __attribute__((overloadable)) asin(half8);
//half16 const_func __attribute__((overloadable)) asin(half16);
/**
* Inverse hyperbolic sine.
*/
float const_func __attribute__((overloadable)) asinh(float);
float2 const_func __attribute__((overloadable)) asinh(float2);
float3 const_func __attribute__((overloadable)) asinh(float3);
float4 const_func __attribute__((overloadable)) asinh(float4);
float8 const_func __attribute__((overloadable)) asinh(float8);
float16 const_func __attribute__((overloadable)) asinh(float16);
double const_func __attribute__((overloadable)) asinh(double);
double2 const_func __attribute__((overloadable)) asinh(double2);
double3 const_func __attribute__((overloadable)) asinh(double3);
double4 const_func __attribute__((overloadable)) asinh(double4);
double8 const_func __attribute__((overloadable)) asinh(double8);
double16 const_func __attribute__((overloadable)) asinh(double16);
//half const_func __attribute__((overloadable)) asinh(half);
//half2 const_func __attribute__((overloadable)) asinh(half2);
//half3 const_func __attribute__((overloadable)) asinh(half3);
//half4 const_func __attribute__((overloadable)) asinh(half4);
//half8 const_func __attribute__((overloadable)) asinh(half8);
//half16 const_func __attribute__((overloadable)) asinh(half16);
/**
* Compute asin (x) / PI.
*/
float const_func __attribute__((overloadable)) asinpi(float x);
float2 const_func __attribute__((overloadable)) asinpi(float2 x);
float3 const_func __attribute__((overloadable)) asinpi(float3 x);
float4 const_func __attribute__((overloadable)) asinpi(float4 x);
float8 const_func __attribute__((overloadable)) asinpi(float8 x);
float16 const_func __attribute__((overloadable)) asinpi(float16 x);
double const_func __attribute__((overloadable)) asinpi(double x);
double2 const_func __attribute__((overloadable)) asinpi(double2 x);
double3 const_func __attribute__((overloadable)) asinpi(double3 x);
double4 const_func __attribute__((overloadable)) asinpi(double4 x);
double8 const_func __attribute__((overloadable)) asinpi(double8 x);
double16 const_func __attribute__((overloadable)) asinpi(double16 x);
//half const_func __attribute__((overloadable)) asinpi(half x);
//half2 const_func __attribute__((overloadable)) asinpi(half2 x);
//half3 const_func __attribute__((overloadable)) asinpi(half3 x);
//half4 const_func __attribute__((overloadable)) asinpi(half4 x);
//half8 const_func __attribute__((overloadable)) asinpi(half8 x);
//half16 const_func __attribute__((overloadable)) asinpi(half16 x);
/**
* Arc tangent function.
*/
float const_func __attribute__((overloadable)) atan(float y_over_x);
float2 const_func __attribute__((overloadable)) atan(float2 y_over_x);
float3 const_func __attribute__((overloadable)) atan(float3 y_over_x);
float4 const_func __attribute__((overloadable)) atan(float4 y_over_x);
float8 const_func __attribute__((overloadable)) atan(float8 y_over_x);
float16 const_func __attribute__((overloadable)) atan(float16 y_over_x);
double const_func __attribute__((overloadable)) atan(double y_over_x);
double2 const_func __attribute__((overloadable)) atan(double2 y_over_x);
double3 const_func __attribute__((overloadable)) atan(double3 y_over_x);
double4 const_func __attribute__((overloadable)) atan(double4 y_over_x);
double8 const_func __attribute__((overloadable)) atan(double8 y_over_x);
double16 const_func __attribute__((overloadable)) atan(double16 y_over_x);
//half const_func __attribute__((overloadable)) atan(half y_over_x);
//half2 const_func __attribute__((overloadable)) atan(half2 y_over_x);
//half3 const_func __attribute__((overloadable)) atan(half3 y_over_x);
//half4 const_func __attribute__((overloadable)) atan(half4 y_over_x);
//half8 const_func __attribute__((overloadable)) atan(half8 y_over_x);
//half16 const_func __attribute__((overloadable)) atan(half16 y_over_x);
/**
* Arc tangent of y / x.
*/
float const_func __attribute__((overloadable)) atan2(float y, float x);
float2 const_func __attribute__((overloadable)) atan2(float2 y, float2 x);
float3 const_func __attribute__((overloadable)) atan2(float3 y, float3 x);
float4 const_func __attribute__((overloadable)) atan2(float4 y, float4 x);
float8 const_func __attribute__((overloadable)) atan2(float8 y, float8 x);
float16 const_func __attribute__((overloadable)) atan2(float16 y, float16 x);
double const_func __attribute__((overloadable)) atan2(double y, double x);
double2 const_func __attribute__((overloadable)) atan2(double2 y, double2 x);
double3 const_func __attribute__((overloadable)) atan2(double3 y, double3 x);
double4 const_func __attribute__((overloadable)) atan2(double4 y, double4 x);
double8 const_func __attribute__((overloadable)) atan2(double8 y, double8 x);
double16 const_func __attribute__((overloadable)) atan2(double16 y, double16 x);
//half const_func __attribute__((overloadable)) atan2(half y, half x);
//half2 const_func __attribute__((overloadable)) atan2(half2 y, half2 x);
//half3 const_func __attribute__((overloadable)) atan2(half3 y, half3 x);
//half4 const_func __attribute__((overloadable)) atan2(half4 y, half4 x);
//half8 const_func __attribute__((overloadable)) atan2(half8 y, half8 x);
//half16 const_func __attribute__((overloadable)) atan2(half16 y, half16 x);
/**
* Hyperbolic arc tangent.
*/
float const_func __attribute__((overloadable)) atanh(float);
float2 const_func __attribute__((overloadable)) atanh(float2);
float3 const_func __attribute__((overloadable)) atanh(float3);
float4 const_func __attribute__((overloadable)) atanh(float4);
float8 const_func __attribute__((overloadable)) atanh(float8);
float16 const_func __attribute__((overloadable)) atanh(float16);
double const_func __attribute__((overloadable)) atanh(double);
double2 const_func __attribute__((overloadable)) atanh(double2);
double3 const_func __attribute__((overloadable)) atanh(double3);
double4 const_func __attribute__((overloadable)) atanh(double4);
double8 const_func __attribute__((overloadable)) atanh(double8);
double16 const_func __attribute__((overloadable)) atanh(double16);
//half const_func __attribute__((overloadable)) atanh(half);
//half2 const_func __attribute__((overloadable)) atanh(half2);
//half3 const_func __attribute__((overloadable)) atanh(half3);
//half4 const_func __attribute__((overloadable)) atanh(half4);
//half8 const_func __attribute__((overloadable)) atanh(half8);
//half16 const_func __attribute__((overloadable)) atanh(half16);
/**
* Compute atan (x) / PI.
*/
float const_func __attribute__((overloadable)) atanpi(float x);
float2 const_func __attribute__((overloadable)) atanpi(float2 x);
float3 const_func __attribute__((overloadable)) atanpi(float3 x);
float4 const_func __attribute__((overloadable)) atanpi(float4 x);
float8 const_func __attribute__((overloadable)) atanpi(float8 x);
float16 const_func __attribute__((overloadable)) atanpi(float16 x);
double const_func __attribute__((overloadable)) atanpi(double x);
double2 const_func __attribute__((overloadable)) atanpi(double2 x);
double3 const_func __attribute__((overloadable)) atanpi(double3 x);
double4 const_func __attribute__((overloadable)) atanpi(double4 x);
double8 const_func __attribute__((overloadable)) atanpi(double8 x);
double16 const_func __attribute__((overloadable)) atanpi(double16 x);
//half const_func __attribute__((overloadable)) atanpi(half x);
//half2 const_func __attribute__((overloadable)) atanpi(half2 x);
//half3 const_func __attribute__((overloadable)) atanpi(half3 x);
//half4 const_func __attribute__((overloadable)) atanpi(half4 x);
//half8 const_func __attribute__((overloadable)) atanpi(half8 x);
//half16 const_func __attribute__((overloadable)) atanpi(half16 x);
/**
* Compute atan2 (y, x) / PI.
*/
float const_func __attribute__((overloadable)) atan2pi(float y, float x);
float2 const_func __attribute__((overloadable)) atan2pi(float2 y, float2 x);
float3 const_func __attribute__((overloadable)) atan2pi(float3 y, float3 x);
float4 const_func __attribute__((overloadable)) atan2pi(float4 y, float4 x);
float8 const_func __attribute__((overloadable)) atan2pi(float8 y, float8 x);
float16 const_func __attribute__((overloadable)) atan2pi(float16 y, float16 x);
double const_func __attribute__((overloadable)) atan2pi(double y, double x);
double2 const_func __attribute__((overloadable)) atan2pi(double2 y, double2 x);
double3 const_func __attribute__((overloadable)) atan2pi(double3 y, double3 x);
double4 const_func __attribute__((overloadable)) atan2pi(double4 y, double4 x);
double8 const_func __attribute__((overloadable)) atan2pi(double8 y, double8 x);
double16 const_func __attribute__((overloadable)) atan2pi(double16 y, double16 x);
//half const_func __attribute__((overloadable)) atan2pi(half y, half x);
//half2 const_func __attribute__((overloadable)) atan2pi(half2 y, half2 x);
//half3 const_func __attribute__((overloadable)) atan2pi(half3 y, half3 x);
//half4 const_func __attribute__((overloadable)) atan2pi(half4 y, half4 x);
//half8 const_func __attribute__((overloadable)) atan2pi(half8 y, half8 x);
//half16 const_func __attribute__((overloadable)) atan2pi(half16 y, half16 x);
/**
* Compute cube-root.
*/
float const_func __attribute__((overloadable)) cbrt(float);
float2 const_func __attribute__((overloadable)) cbrt(float2);
float3 const_func __attribute__((overloadable)) cbrt(float3);
float4 const_func __attribute__((overloadable)) cbrt(float4);
float8 const_func __attribute__((overloadable)) cbrt(float8);
float16 const_func __attribute__((overloadable)) cbrt(float16);
double const_func __attribute__((overloadable)) cbrt(double);
double2 const_func __attribute__((overloadable)) cbrt(double2);
double3 const_func __attribute__((overloadable)) cbrt(double3);
double4 const_func __attribute__((overloadable)) cbrt(double4);
double8 const_func __attribute__((overloadable)) cbrt(double8);
double16 const_func __attribute__((overloadable)) cbrt(double16);
//half const_func __attribute__((overloadable)) cbrt(half);
//half2 const_func __attribute__((overloadable)) cbrt(half2);
//half3 const_func __attribute__((overloadable)) cbrt(half3);
//half4 const_func __attribute__((overloadable)) cbrt(half4);
//half8 const_func __attribute__((overloadable)) cbrt(half8);
//half16 const_func __attribute__((overloadable)) cbrt(half16);
/**
* Round to integral value using the round to +ve
* infinity rounding mode.
*/
float const_func __attribute__((overloadable)) ceil(float);
float2 const_func __attribute__((overloadable)) ceil(float2);
float3 const_func __attribute__((overloadable)) ceil(float3);
float4 const_func __attribute__((overloadable)) ceil(float4);
float8 const_func __attribute__((overloadable)) ceil(float8);
float16 const_func __attribute__((overloadable)) ceil(float16);
double const_func __attribute__((overloadable)) ceil(double);
double2 const_func __attribute__((overloadable)) ceil(double2);
double3 const_func __attribute__((overloadable)) ceil(double3);
double4 const_func __attribute__((overloadable)) ceil(double4);
double8 const_func __attribute__((overloadable)) ceil(double8);
double16 const_func __attribute__((overloadable)) ceil(double16);
//half const_func __attribute__((overloadable)) ceil(half);
//half2 const_func __attribute__((overloadable)) ceil(half2);
//half3 const_func __attribute__((overloadable)) ceil(half3);
//half4 const_func __attribute__((overloadable)) ceil(half4);
//half8 const_func __attribute__((overloadable)) ceil(half8);
//half16 const_func __attribute__((overloadable)) ceil(half16);
/**
* Returns x with its sign changed to match the sign of
* y.
*/
float const_func __attribute__((overloadable)) copysign(float x, float y);
float2 const_func __attribute__((overloadable)) copysign(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) copysign(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) copysign(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) copysign(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) copysign(float16 x, float16 y);
double const_func __attribute__((overloadable)) copysign(double x, double y);
double2 const_func __attribute__((overloadable)) copysign(double2 x, double2 y);
double3 const_func __attribute__((overloadable)) copysign(double3 x, double3 y);
double4 const_func __attribute__((overloadable)) copysign(double4 x, double4 y);
double8 const_func __attribute__((overloadable)) copysign(double8 x, double8 y);
double16 const_func __attribute__((overloadable)) copysign(double16 x, double16 y);
//half const_func __attribute__((overloadable)) copysign(half x, half y);
//half2 const_func __attribute__((overloadable)) copysign(half2 x, half2 y);
//half3 const_func __attribute__((overloadable)) copysign(half3 x, half3 y);
//half4 const_func __attribute__((overloadable)) copysign(half4 x, half4 y);
//half8 const_func __attribute__((overloadable)) copysign(half8 x, half8 y);
//half16 const_func __attribute__((overloadable)) copysign(half16 x, half16 y);
/**
* Compute cosine.
*/
double const_func __attribute__((overloadable)) cos(double);
double2 const_func __attribute__((overloadable)) cos(double2);
double3 const_func __attribute__((overloadable)) cos(double3);
double4 const_func __attribute__((overloadable)) cos(double4);
double8 const_func __attribute__((overloadable)) cos(double8);
double16 const_func __attribute__((overloadable)) cos(double16);
float const_func __attribute__((overloadable)) cos(float);
float2 const_func __attribute__((overloadable)) cos(float2);
float3 const_func __attribute__((overloadable)) cos(float3);
float4 const_func __attribute__((overloadable)) cos(float4);
float8 const_func __attribute__((overloadable)) cos(float8);
float16 const_func __attribute__((overloadable)) cos(float16);
//half const_func __attribute__((overloadable)) cos(half);
//half2 const_func __attribute__((overloadable)) cos(half2);
//half3 const_func __attribute__((overloadable)) cos(half3);
//half4 const_func __attribute__((overloadable)) cos(half4);
//half8 const_func __attribute__((overloadable)) cos(half8);
//half16 const_func __attribute__((overloadable)) cos(half16);
/**
* Compute hyperbolic consine.
*/
float const_func __attribute__((overloadable)) cosh(float);
float2 const_func __attribute__((overloadable)) cosh(float2);
float3 const_func __attribute__((overloadable)) cosh(float3);
float4 const_func __attribute__((overloadable)) cosh(float4);
float8 const_func __attribute__((overloadable)) cosh(float8);
float16 const_func __attribute__((overloadable)) cosh(float16);
double const_func __attribute__((overloadable)) cosh(double);
double2 const_func __attribute__((overloadable)) cosh(double2);
double3 const_func __attribute__((overloadable)) cosh(double3);
double4 const_func __attribute__((overloadable)) cosh(double4);
double8 const_func __attribute__((overloadable)) cosh(double8);
double16 const_func __attribute__((overloadable)) cosh(double16);
//half const_func __attribute__((overloadable)) cosh(half);
//half2 const_func __attribute__((overloadable)) cosh(half2);
//half3 const_func __attribute__((overloadable)) cosh(half3);
//half4 const_func __attribute__((overloadable)) cosh(half4);
//half8 const_func __attribute__((overloadable)) cosh(half8);
//half16 const_func __attribute__((overloadable)) cosh(half16);
/**
* Compute cos (PI * x).
*/
float const_func __attribute__((overloadable)) cospi(float x);
float2 const_func __attribute__((overloadable)) cospi(float2 x);
float3 const_func __attribute__((overloadable)) cospi(float3 x);
float4 const_func __attribute__((overloadable)) cospi(float4 x);
float8 const_func __attribute__((overloadable)) cospi(float8 x);
float16 const_func __attribute__((overloadable)) cospi(float16 x);
double const_func __attribute__((overloadable)) cospi(double x);
double2 const_func __attribute__((overloadable)) cospi(double2 x);
double3 const_func __attribute__((overloadable)) cospi(double3 x);
double4 const_func __attribute__((overloadable)) cospi(double4 x);
double8 const_func __attribute__((overloadable)) cospi(double8 x);
double16 const_func __attribute__((overloadable)) cospi(double16 x);
//half const_func __attribute__((overloadable)) cospi(half x);
//half2 const_func __attribute__((overloadable)) cospi(half2 x);
//half3 const_func __attribute__((overloadable)) cospi(half3 x);
//half4 const_func __attribute__((overloadable)) cospi(half4 x);
//half8 const_func __attribute__((overloadable)) cospi(half8 x);
//half16 const_func __attribute__((overloadable)) cospi(half16 x);
/**
* Complementary error function.
*/
float const_func __attribute__((overloadable)) erfc(float);
float2 const_func __attribute__((overloadable)) erfc(float2);
float3 const_func __attribute__((overloadable)) erfc(float3);
float4 const_func __attribute__((overloadable)) erfc(float4);
float8 const_func __attribute__((overloadable)) erfc(float8);
float16 const_func __attribute__((overloadable)) erfc(float16);
double const_func __attribute__((overloadable)) erfc(double);
double2 const_func __attribute__((overloadable)) erfc(double2);
double3 const_func __attribute__((overloadable)) erfc(double3);
double4 const_func __attribute__((overloadable)) erfc(double4);
double8 const_func __attribute__((overloadable)) erfc(double8);
double16 const_func __attribute__((overloadable)) erfc(double16);
//half const_func __attribute__((overloadable)) erfc(half);
//half2 const_func __attribute__((overloadable)) erfc(half2);
//half3 const_func __attribute__((overloadable)) erfc(half3);
//half4 const_func __attribute__((overloadable)) erfc(half4);
//half8 const_func __attribute__((overloadable)) erfc(half8);
//half16 const_func __attribute__((overloadable)) erfc(half16);
/**
* Error function encountered in integrating the
* normal distribution.
*/
float const_func __attribute__((overloadable)) erf(float);
float2 const_func __attribute__((overloadable)) erf(float2);
float3 const_func __attribute__((overloadable)) erf(float3);
float4 const_func __attribute__((overloadable)) erf(float4);
float8 const_func __attribute__((overloadable)) erf(float8);
float16 const_func __attribute__((overloadable)) erf(float16);
double const_func __attribute__((overloadable)) erf(double);
double2 const_func __attribute__((overloadable)) erf(double2);
double3 const_func __attribute__((overloadable)) erf(double3);
double4 const_func __attribute__((overloadable)) erf(double4);
double8 const_func __attribute__((overloadable)) erf(double8);
double16 const_func __attribute__((overloadable)) erf(double16);
//half const_func __attribute__((overloadable)) erf(half);
//half2 const_func __attribute__((overloadable)) erf(half2);
//half3 const_func __attribute__((overloadable)) erf(half3);
//half4 const_func __attribute__((overloadable)) erf(half4);
//half8 const_func __attribute__((overloadable)) erf(half8);
//half16 const_func __attribute__((overloadable)) erf(half16);
/**
* Compute the base- e exponential of x.
*/
float const_func __attribute__((overloadable)) exp(float x);
float2 const_func __attribute__((overloadable)) exp(float2 x);
float3 const_func __attribute__((overloadable)) exp(float3 x);
float4 const_func __attribute__((overloadable)) exp(float4 x);
float8 const_func __attribute__((overloadable)) exp(float8 x);
float16 const_func __attribute__((overloadable)) exp(float16 x);
double const_func __attribute__((overloadable)) exp(double x);
double2 const_func __attribute__((overloadable)) exp(double2 x);
double3 const_func __attribute__((overloadable)) exp(double3 x);
double4 const_func __attribute__((overloadable)) exp(double4 x);
double8 const_func __attribute__((overloadable)) exp(double8 x);
double16 const_func __attribute__((overloadable)) exp(double16 x);
//half const_func __attribute__((overloadable)) exp(half x);
//half2 const_func __attribute__((overloadable)) exp(half2 x);
//half3 const_func __attribute__((overloadable)) exp(half3 x);
//half4 const_func __attribute__((overloadable)) exp(half4 x);
//half8 const_func __attribute__((overloadable)) exp(half8 x);
//half16 const_func __attribute__((overloadable)) exp(half16 x);
/**
* Exponential base 2 function.
*/
float const_func __attribute__((overloadable)) exp2(float);
float2 const_func __attribute__((overloadable)) exp2(float2);
float3 const_func __attribute__((overloadable)) exp2(float3);
float4 const_func __attribute__((overloadable)) exp2(float4);
float8 const_func __attribute__((overloadable)) exp2(float8);
float16 const_func __attribute__((overloadable)) exp2(float16);
double const_func __attribute__((overloadable)) exp2(double);
double2 const_func __attribute__((overloadable)) exp2(double2);
double3 const_func __attribute__((overloadable)) exp2(double3);
double4 const_func __attribute__((overloadable)) exp2(double4);
double8 const_func __attribute__((overloadable)) exp2(double8);
double16 const_func __attribute__((overloadable)) exp2(double16);
//half const_func __attribute__((overloadable)) exp2(half);
//half2 const_func __attribute__((overloadable)) exp2(half2);
//half3 const_func __attribute__((overloadable)) exp2(half3);
//half4 const_func __attribute__((overloadable)) exp2(half4);
//half8 const_func __attribute__((overloadable)) exp2(half8);
//half16 const_func __attribute__((overloadable)) exp2(half16);
/**
* Exponential base 10 function.
*/
float const_func __attribute__((overloadable)) exp10(float);
float2 const_func __attribute__((overloadable)) exp10(float2);
float3 const_func __attribute__((overloadable)) exp10(float3);
float4 const_func __attribute__((overloadable)) exp10(float4);
float8 const_func __attribute__((overloadable)) exp10(float8);
float16 const_func __attribute__((overloadable)) exp10(float16);
double const_func __attribute__((overloadable)) exp10(double);
double2 const_func __attribute__((overloadable)) exp10(double2);
double3 const_func __attribute__((overloadable)) exp10(double3);
double4 const_func __attribute__((overloadable)) exp10(double4);
double8 const_func __attribute__((overloadable)) exp10(double8);
double16 const_func __attribute__((overloadable)) exp10(double16);
//half const_func __attribute__((overloadable)) exp10(half);
//half2 const_func __attribute__((overloadable)) exp10(half2);
//half3 const_func __attribute__((overloadable)) exp10(half3);
//half4 const_func __attribute__((overloadable)) exp10(half4);
//half8 const_func __attribute__((overloadable)) exp10(half8);
//half16 const_func __attribute__((overloadable)) exp10(half16);
/**
* Compute e^x- 1.0.
*/
float const_func __attribute__((overloadable)) expm1(float x);
float2 const_func __attribute__((overloadable)) expm1(float2 x);
float3 const_func __attribute__((overloadable)) expm1(float3 x);
float4 const_func __attribute__((overloadable)) expm1(float4 x);
float8 const_func __attribute__((overloadable)) expm1(float8 x);
float16 const_func __attribute__((overloadable)) expm1(float16 x);
double const_func __attribute__((overloadable)) expm1(double x);
double2 const_func __attribute__((overloadable)) expm1(double2 x);
double3 const_func __attribute__((overloadable)) expm1(double3 x);
double4 const_func __attribute__((overloadable)) expm1(double4 x);
double8 const_func __attribute__((overloadable)) expm1(double8 x);
double16 const_func __attribute__((overloadable)) expm1(double16 x);
//half const_func __attribute__((overloadable)) expm1(half x);
//half2 const_func __attribute__((overloadable)) expm1(half2 x);
//half3 const_func __attribute__((overloadable)) expm1(half3 x);
//half4 const_func __attribute__((overloadable)) expm1(half4 x);
//half8 const_func __attribute__((overloadable)) expm1(half8 x);
//half16 const_func __attribute__((overloadable)) expm1(half16 x);
/**
* Compute absolute value of a floating-point number.
*/
float const_func __attribute__((overloadable)) fabs(float);
float2 const_func __attribute__((overloadable)) fabs(float2);
float3 const_func __attribute__((overloadable)) fabs(float3);
float4 const_func __attribute__((overloadable)) fabs(float4);
float8 const_func __attribute__((overloadable)) fabs(float8);
float16 const_func __attribute__((overloadable)) fabs(float16);
double const_func __attribute__((overloadable)) fabs(double);
double2 const_func __attribute__((overloadable)) fabs(double2);
double3 const_func __attribute__((overloadable)) fabs(double3);
double4 const_func __attribute__((overloadable)) fabs(double4);
double8 const_func __attribute__((overloadable)) fabs(double8);
double16 const_func __attribute__((overloadable)) fabs(double16);
//half const_func __attribute__((overloadable)) fabs(half);
//half2 const_func __attribute__((overloadable)) fabs(half2);
//half3 const_func __attribute__((overloadable)) fabs(half3);
//half4 const_func __attribute__((overloadable)) fabs(half4);
//half8 const_func __attribute__((overloadable)) fabs(half8);
//half16 const_func __attribute__((overloadable)) fabs(half16);
/**
* x - y if x > y, +0 if x is less than or equal to y.
*/
float const_func __attribute__((overloadable)) fdim(float x, float y);
float2 const_func __attribute__((overloadable)) fdim(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) fdim(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) fdim(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) fdim(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) fdim(float16 x, float16 y);
double const_func __attribute__((overloadable)) fdim(double x, double y);
double2 const_func __attribute__((overloadable)) fdim(double2 x, double2 y);
double3 const_func __attribute__((overloadable)) fdim(double3 x, double3 y);
double4 const_func __attribute__((overloadable)) fdim(double4 x, double4 y);
double8 const_func __attribute__((overloadable)) fdim(double8 x, double8 y);
double16 const_func __attribute__((overloadable)) fdim(double16 x, double16 y);
//half const_func __attribute__((overloadable)) fdim(half x, half y);
//half2 const_func __attribute__((overloadable)) fdim(half2 x, half2 y);
//half3 const_func __attribute__((overloadable)) fdim(half3 x, half3 y);
//half4 const_func __attribute__((overloadable)) fdim(half4 x, half4 y);
//half8 const_func __attribute__((overloadable)) fdim(half8 x, half8 y);
//half16 const_func __attribute__((overloadable)) fdim(half16 x, half16 y);
/**
* Round to integral value using the round to –ve
* infinity rounding mode.
*/
float const_func __attribute__((overloadable)) floor(float);
float2 const_func __attribute__((overloadable)) floor(float2);
float3 const_func __attribute__((overloadable)) floor(float3);
float4 const_func __attribute__((overloadable)) floor(float4);
float8 const_func __attribute__((overloadable)) floor(float8);
float16 const_func __attribute__((overloadable)) floor(float16);
double const_func __attribute__((overloadable)) floor(double);
double2 const_func __attribute__((overloadable)) floor(double2);
double3 const_func __attribute__((overloadable)) floor(double3);
double4 const_func __attribute__((overloadable)) floor(double4);
double8 const_func __attribute__((overloadable)) floor(double8);
double16 const_func __attribute__((overloadable)) floor(double16);
//half const_func __attribute__((overloadable)) floor(half);
//half2 const_func __attribute__((overloadable)) floor(half2);
//half3 const_func __attribute__((overloadable)) floor(half3);
//half4 const_func __attribute__((overloadable)) floor(half4);
//half8 const_func __attribute__((overloadable)) floor(half8);
//half16 const_func __attribute__((overloadable)) floor(half16);
/**
* Returns the correctly rounded floating-point
* representation of the sum of c with the infinitely
* precise product of a and b. Rounding of
* intermediate products shall not occur. Edge case
* behavior is per the IEEE 754-2008 standard.
*/
float const_func __attribute__((overloadable)) fma(float a, float b, float c);
float2 const_func __attribute__((overloadable)) fma(float2 a, float2 b, float2 c);
float3 const_func __attribute__((overloadable)) fma(float3 a, float3 b, float3 c);
float4 const_func __attribute__((overloadable)) fma(float4 a, float4 b, float4 c);
float8 const_func __attribute__((overloadable)) fma(float8 a, float8 b, float8 c);
float16 const_func __attribute__((overloadable)) fma(float16 a, float16 b, float16 c);
double const_func __attribute__((overloadable)) fma(double a, double b, double c);
double2 const_func __attribute__((overloadable)) fma(double2 a, double2 b, double2 c);
double3 const_func __attribute__((overloadable)) fma(double3 a, double3 b, double3 c);
double4 const_func __attribute__((overloadable)) fma(double4 a, double4 b, double4 c);
double8 const_func __attribute__((overloadable)) fma(double8 a, double8 b, double8 c);
double16 const_func __attribute__((overloadable)) fma(double16 a, double16 b, double16 c);
//half const_func __attribute__((overloadable)) fma(half a, half b, half c);
//half2 const_func __attribute__((overloadable)) fma(half2 a, half2 b, half2 c);
//half3 const_func __attribute__((overloadable)) fma(half3 a, half3 b, half3 c);
//half4 const_func __attribute__((overloadable)) fma(half4 a, half4 b, half4 c);
//half8 const_func __attribute__((overloadable)) fma(half8 a, half8 b, half8 c);
//half16 const_func __attribute__((overloadable)) fma(half16 a, half16 b, half16 c);
/**
* Returns y if x < y, otherwise it returns x. If one
* argument is a NaN, fmax() returns the other
* argument. If both arguments are NaNs, fmax()
* returns a NaN.
*/
float const_func __attribute__((overloadable)) fmax(float x, float y);
float2 const_func __attribute__((overloadable)) fmax(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) fmax(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) fmax(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) fmax(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) fmax(float16 x, float16 y);
float2 const_func __attribute__((overloadable)) fmax(float2 x, float y);
float3 const_func __attribute__((overloadable)) fmax(float3 x, float y);
float4 const_func __attribute__((overloadable)) fmax(float4 x, float y);
float8 const_func __attribute__((overloadable)) fmax(float8 x, float y);
float16 const_func __attribute__((overloadable)) fmax(float16 x, float y);
double const_func __attribute__((overloadable)) fmax(double x, double y);
double2 const_func __attribute__((overloadable)) fmax(double2 x, double2 y);
double3 const_func __attribute__((overloadable)) fmax(double3 x, double3 y);
double4 const_func __attribute__((overloadable)) fmax(double4 x, double4 y);
double8 const_func __attribute__((overloadable)) fmax(double8 x, double8 y);
double16 const_func __attribute__((overloadable)) fmax(double16 x, double16 y);
double2 const_func __attribute__((overloadable)) fmax(double2 x, double y);
double3 const_func __attribute__((overloadable)) fmax(double3 x, double y);
double4 const_func __attribute__((overloadable)) fmax(double4 x, double y);
double8 const_func __attribute__((overloadable)) fmax(double8 x, double y);
double16 const_func __attribute__((overloadable)) fmax(double16 x, double y);
//half const_func __attribute__((overloadable)) fmax(half x, half y);
//half2 const_func __attribute__((overloadable)) fmax(half2 x, half2 y);
//half3 const_func __attribute__((overloadable)) fmax(half3 x, half3 y);
//half4 const_func __attribute__((overloadable)) fmax(half4 x, half4 y);
//half8 const_func __attribute__((overloadable)) fmax(half8 x, half8 y);
//half16 const_func __attribute__((overloadable)) fmax(half16 x, half16 y);
//half2 const_func __attribute__((overloadable)) fmax(half2 x, half y);
//half3 const_func __attribute__((overloadable)) fmax(half3 x, half y);
//half4 const_func __attribute__((overloadable)) fmax(half4 x, half y);
//half8 const_func __attribute__((overloadable)) fmax(half8 x, half y);
//half16 const_func __attribute__((overloadable)) fmax(half16 x, half y);
/**
* Returns y if y < x, otherwise it returns x. If one
* argument is a NaN, fmin() returns the other
* argument. If both arguments are NaNs, fmin()
* returns a NaN.
*/
float const_func __attribute__((overloadable)) fmin(float x, float y);
float2 const_func __attribute__((overloadable)) fmin(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) fmin(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) fmin(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) fmin(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) fmin(float16 x, float16 y);
float2 const_func __attribute__((overloadable)) fmin(float2 x, float y);
float3 const_func __attribute__((overloadable)) fmin(float3 x, float y);
float4 const_func __attribute__((overloadable)) fmin(float4 x, float y);
float8 const_func __attribute__((overloadable)) fmin(float8 x, float y);
float16 const_func __attribute__((overloadable)) fmin(float16 x, float y);
double const_func __attribute__((overloadable)) fmin(double x, double y);
double2 const_func __attribute__((overloadable)) fmin(double2 x, double2 y);
double3 const_func __attribute__((overloadable)) fmin(double3 x, double3 y);
double4 const_func __attribute__((overloadable)) fmin(double4 x, double4 y);
double8 const_func __attribute__((overloadable)) fmin(double8 x, double8 y);
double16 const_func __attribute__((overloadable)) fmin(double16 x, double16 y);
double2 const_func __attribute__((overloadable)) fmin(double2 x, double y);
double3 const_func __attribute__((overloadable)) fmin(double3 x, double y);
double4 const_func __attribute__((overloadable)) fmin(double4 x, double y);
double8 const_func __attribute__((overloadable)) fmin(double8 x, double y);
double16 const_func __attribute__((overloadable)) fmin(double16 x, double y);
//half const_func __attribute__((overloadable)) fmin(half x, half y);
//half2 const_func __attribute__((overloadable)) fmin(half2 x, half2 y);
//half3 const_func __attribute__((overloadable)) fmin(half3 x, half3 y);
//half4 const_func __attribute__((overloadable)) fmin(half4 x, half4 y);
//half8 const_func __attribute__((overloadable)) fmin(half8 x, half8 y);
//half16 const_func __attribute__((overloadable)) fmin(half16 x, half16 y);
//half2 const_func __attribute__((overloadable)) fmin(half2 x, half y);
//half3 const_func __attribute__((overloadable)) fmin(half3 x, half y);
//half4 const_func __attribute__((overloadable)) fmin(half4 x, half y);
//half8 const_func __attribute__((overloadable)) fmin(half8 x, half y);
//half16 const_func __attribute__((overloadable)) fmin(half16 x, half y);
/**
* Modulus. Returns x – y * trunc (x/y).
*/
float const_func __attribute__((overloadable)) fmod(float x, float y);
float2 const_func __attribute__((overloadable)) fmod(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) fmod(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) fmod(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) fmod(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) fmod(float16 x, float16 y);
double const_func __attribute__((overloadable)) fmod(double x, double y);
double2 const_func __attribute__((overloadable)) fmod(double2 x, double2 y);
double3 const_func __attribute__((overloadable)) fmod(double3 x, double3 y);
double4 const_func __attribute__((overloadable)) fmod(double4 x, double4 y);
double8 const_func __attribute__((overloadable)) fmod(double8 x, double8 y);
double16 const_func __attribute__((overloadable)) fmod(double16 x, double16 y);
//half const_func __attribute__((overloadable)) fmod(half x, half y);
//half2 const_func __attribute__((overloadable)) fmod(half2 x, half2 y);
//half3 const_func __attribute__((overloadable)) fmod(half3 x, half3 y);
//half4 const_func __attribute__((overloadable)) fmod(half4 x, half4 y);
//half8 const_func __attribute__((overloadable)) fmod(half8 x, half8 y);
//half16 const_func __attribute__((overloadable)) fmod(half16 x, half16 y);
/**
* Returns fmin( x – floor (x), 0x1.fffffep-1f ).
* floor(x) is returned in iptr.
*/
float __attribute__((overloadable)) fract(float x, __global float *iptr);
float2 __attribute__((overloadable)) fract(float2 x, __global float2 *iptr);
float3 __attribute__((overloadable)) fract(float3 x, __global float3 *iptr);
float4 __attribute__((overloadable)) fract(float4 x, __global float4 *iptr);
float8 __attribute__((overloadable)) fract(float8 x, __global float8 *iptr);
float16 __attribute__((overloadable)) fract(float16 x, __global float16 *iptr);
float __attribute__((overloadable)) fract(float x, __local float *iptr);
float2 __attribute__((overloadable)) fract(float2 x, __local float2 *iptr);
float3 __attribute__((overloadable)) fract(float3 x, __local float3 *iptr);
float4 __attribute__((overloadable)) fract(float4 x, __local float4 *iptr);
float8 __attribute__((overloadable)) fract(float8 x, __local float8 *iptr);
float16 __attribute__((overloadable)) fract(float16 x, __local float16 *iptr);
float __attribute__((overloadable)) fract(float x, __private float *iptr);
float2 __attribute__((overloadable)) fract(float2 x, __private float2 *iptr);
float3 __attribute__((overloadable)) fract(float3 x, __private float3 *iptr);
float4 __attribute__((overloadable)) fract(float4 x, __private float4 *iptr);
float8 __attribute__((overloadable)) fract(float8 x, __private float8 *iptr);
float16 __attribute__((overloadable)) fract(float16 x, __private float16 *iptr);
double __attribute__((overloadable)) fract(double x, __global double *iptr);
double2 __attribute__((overloadable)) fract(double2 x, __global double2 *iptr);
double3 __attribute__((overloadable)) fract(double3 x, __global double3 *iptr);
double4 __attribute__((overloadable)) fract(double4 x, __global double4 *iptr);
double8 __attribute__((overloadable)) fract(double8 x, __global double8 *iptr);
double16 __attribute__((overloadable)) fract(double16 x, __global double16 *iptr);
double __attribute__((overloadable)) fract(double x, __local double *iptr);
double2 __attribute__((overloadable)) fract(double2 x, __local double2 *iptr);
double3 __attribute__((overloadable)) fract(double3 x, __local double3 *iptr);
double4 __attribute__((overloadable)) fract(double4 x, __local double4 *iptr);
double8 __attribute__((overloadable)) fract(double8 x, __local double8 *iptr);
double16 __attribute__((overloadable)) fract(double16 x, __local double16 *iptr);
double __attribute__((overloadable)) fract(double x, __private double *iptr);
double2 __attribute__((overloadable)) fract(double2 x, __private double2 *iptr);
double3 __attribute__((overloadable)) fract(double3 x, __private double3 *iptr);
double4 __attribute__((overloadable)) fract(double4 x, __private double4 *iptr);
double8 __attribute__((overloadable)) fract(double8 x, __private double8 *iptr);
double16 __attribute__((overloadable)) fract(double16 x, __private double16 *iptr);
//half __attribute__((overloadable)) fract(half x, __global half *iptr);
//half2 __attribute__((overloadable)) fract(half2 x, __global half2 *iptr);
//half3 __attribute__((overloadable)) fract(half3 x, __global half3 *iptr);
//half4 __attribute__((overloadable)) fract(half4 x, __global half4 *iptr);
//half8 __attribute__((overloadable)) fract(half8 x, __global half8 *iptr);
//half16 __attribute__((overloadable)) fract(half16 x, __global half16 *iptr);
//half __attribute__((overloadable)) fract(half x, __local half *iptr);
//half2 __attribute__((overloadable)) fract(half2 x, __local half2 *iptr);
//half3 __attribute__((overloadable)) fract(half3 x, __local half3 *iptr);
//half4 __attribute__((overloadable)) fract(half4 x, __local half4 *iptr);
//half8 __attribute__((overloadable)) fract(half8 x, __local half8 *iptr);
//half16 __attribute__((overloadable)) fract(half16 x, __local half16 *iptr);
//half __attribute__((overloadable)) fract(half x, __private half *iptr);
//half2 __attribute__((overloadable)) fract(half2 x, __private half2 *iptr);
//half3 __attribute__((overloadable)) fract(half3 x, __private half3 *iptr);
//half4 __attribute__((overloadable)) fract(half4 x, __private half4 *iptr);
//half8 __attribute__((overloadable)) fract(half8 x, __private half8 *iptr);
//half16 __attribute__((overloadable)) fract(half16 x, __private half16 *iptr);
/**
* Extract mantissa and exponent from x. For each
* component the mantissa returned is a float with
* magnitude in the interval [1/2, 1) or 0. Each
* component of x equals mantissa returned * 2^exp.
*/
float __attribute__((overloadable)) frexp(float x, __global int *exp);
float2 __attribute__((overloadable)) frexp(float2 x, __global int2 *exp);
float3 __attribute__((overloadable)) frexp(float3 x, __global int3 *exp);
float4 __attribute__((overloadable)) frexp(float4 x, __global int4 *exp);
float8 __attribute__((overloadable)) frexp(float8 x, __global int8 *exp);
float16 __attribute__((overloadable)) frexp(float16 x, __global int16 *exp);
float __attribute__((overloadable)) frexp(float x, __local int *exp);
float2 __attribute__((overloadable)) frexp(float2 x, __local int2 *exp);
float3 __attribute__((overloadable)) frexp(float3 x, __local int3 *exp);
float4 __attribute__((overloadable)) frexp(float4 x, __local int4 *exp);
float8 __attribute__((overloadable)) frexp(float8 x, __local int8 *exp);
float16 __attribute__((overloadable)) frexp(float16 x, __local int16 *exp);
float __attribute__((overloadable)) frexp(float x, __private int *exp);
float2 __attribute__((overloadable)) frexp(float2 x, __private int2 *exp);
float3 __attribute__((overloadable)) frexp(float3 x, __private int3 *exp);
float4 __attribute__((overloadable)) frexp(float4 x, __private int4 *exp);
float8 __attribute__((overloadable)) frexp(float8 x, __private int8 *exp);
float16 __attribute__((overloadable)) frexp(float16 x, __private int16 *exp);
double __attribute__((overloadable)) frexp(double x, __global int *exp);
double2 __attribute__((overloadable)) frexp(double2 x, __global int2 *exp);
double3 __attribute__((overloadable)) frexp(double3 x, __global int3 *exp);
double4 __attribute__((overloadable)) frexp(double4 x, __global int4 *exp);
double8 __attribute__((overloadable)) frexp(double8 x, __global int8 *exp);
double16 __attribute__((overloadable)) frexp(double16 x, __global int16 *exp);
double __attribute__((overloadable)) frexp(double x, __local int *exp);
double2 __attribute__((overloadable)) frexp(double2 x, __local int2 *exp);
double3 __attribute__((overloadable)) frexp(double3 x, __local int3 *exp);
double4 __attribute__((overloadable)) frexp(double4 x, __local int4 *exp);
double8 __attribute__((overloadable)) frexp(double8 x, __local int8 *exp);
double16 __attribute__((overloadable)) frexp(double16 x, __local int16 *exp);
double __attribute__((overloadable)) frexp(double x, __private int *exp);
double2 __attribute__((overloadable)) frexp(double2 x, __private int2 *exp);
double3 __attribute__((overloadable)) frexp(double3 x, __private int3 *exp);
double4 __attribute__((overloadable)) frexp(double4 x, __private int4 *exp);
double8 __attribute__((overloadable)) frexp(double8 x, __private int8 *exp);
double16 __attribute__((overloadable)) frexp(double16 x, __private int16 *exp);
//half __attribute__((overloadable)) frexp(half x, __global int *exp);
//half2 __attribute__((overloadable)) frexp(half2 x, __global int2 *exp);
//half3 __attribute__((overloadable)) frexp(half3 x, __global int3 *exp);
//half4 __attribute__((overloadable)) frexp(half4 x, __global int4 *exp);
//half8 __attribute__((overloadable)) frexp(half8 x, __global int8 *exp);
//half16 __attribute__((overloadable)) frexp(half16 x, __global int16 *exp);
//half __attribute__((overloadable)) frexp(half x, __local int *exp);
//half2 __attribute__((overloadable)) frexp(half2 x, __local int2 *exp);
//half3 __attribute__((overloadable)) frexp(half3 x, __local int3 *exp);
//half4 __attribute__((overloadable)) frexp(half4 x, __local int4 *exp);
//half8 __attribute__((overloadable)) frexp(half8 x, __local int8 *exp);
//half16 __attribute__((overloadable)) frexp(half16 x, __local int16 *exp);
//half __attribute__((overloadable)) frexp(half x, __private int *exp);
//half2 __attribute__((overloadable)) frexp(half2 x, __private int2 *exp);
//half3 __attribute__((overloadable)) frexp(half3 x, __private int3 *exp);
//half4 __attribute__((overloadable)) frexp(half4 x, __private int4 *exp);
//half8 __attribute__((overloadable)) frexp(half8 x, __private int8 *exp);
//half16 __attribute__((overloadable)) frexp(half16 x, __private int16 *exp);
/**
* Compute the value of the square root of x^2+ y^2
* without undue overflow or underflow.
*/
float const_func __attribute__((overloadable)) hypot(float x, float y);
float2 const_func __attribute__((overloadable)) hypot(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) hypot(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) hypot(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) hypot(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) hypot(float16 x, float16 y);
double const_func __attribute__((overloadable)) hypot(double x, double y);
double2 const_func __attribute__((overloadable)) hypot(double2 x, double2 y);
double3 const_func __attribute__((overloadable)) hypot(double3 x, double3 y);
double4 const_func __attribute__((overloadable)) hypot(double4 x, double4 y);
double8 const_func __attribute__((overloadable)) hypot(double8 x, double8 y);
double16 const_func __attribute__((overloadable)) hypot(double16 x, double16 y);
//half const_func __attribute__((overloadable)) hypot(half x, half y);
//half2 const_func __attribute__((overloadable)) hypot(half2 x, half2 y);
//half3 const_func __attribute__((overloadable)) hypot(half3 x, half3 y);
//half4 const_func __attribute__((overloadable)) hypot(half4 x, half4 y);
//half8 const_func __attribute__((overloadable)) hypot(half8 x, half8 y);
//half16 const_func __attribute__((overloadable)) hypot(half16 x, half16 y);
/**
* Return the exponent as an integer value.
*/
int const_func __attribute__((overloadable)) ilogb(float x);
int2 const_func __attribute__((overloadable)) ilogb(float2 x);
int3 const_func __attribute__((overloadable)) ilogb(float3 x);
int4 const_func __attribute__((overloadable)) ilogb(float4 x);
int8 const_func __attribute__((overloadable)) ilogb(float8 x);
int16 const_func __attribute__((overloadable)) ilogb(float16 x);
int const_func __attribute__((overloadable)) ilogb(double x);
int2 const_func __attribute__((overloadable)) ilogb(double2 x);
int3 const_func __attribute__((overloadable)) ilogb(double3 x);
int4 const_func __attribute__((overloadable)) ilogb(double4 x);
int8 const_func __attribute__((overloadable)) ilogb(double8 x);
int16 const_func __attribute__((overloadable)) ilogb(double16 x);
//int const_func __attribute__((overloadable)) ilogb(half x);
//int2 const_func __attribute__((overloadable)) ilogb(half2 x);
//int3 const_func __attribute__((overloadable)) ilogb(half3 x);
//int4 const_func __attribute__((overloadable)) ilogb(half4 x);
//int8 const_func __attribute__((overloadable)) ilogb(half8 x);
//int16 const_func __attribute__((overloadable)) ilogb(half16 x);
/**
* Multiply x by 2 to the power n.
*/
float const_func __attribute__((overloadable)) ldexp(float x, int n);
float2 const_func __attribute__((overloadable)) ldexp(float2 x, int2 n);
float3 const_func __attribute__((overloadable)) ldexp(float3 x, int3 n);
float4 const_func __attribute__((overloadable)) ldexp(float4 x, int4 n);
float8 const_func __attribute__((overloadable)) ldexp(float8 x, int8 n);
float16 const_func __attribute__((overloadable)) ldexp(float16 x, int16 n);
float2 const_func __attribute__((overloadable)) ldexp(float2 x, int n);
float3 const_func __attribute__((overloadable)) ldexp(float3 x, int n);
float4 const_func __attribute__((overloadable)) ldexp(float4 x, int n);
float8 const_func __attribute__((overloadable)) ldexp(float8 x, int n);
float16 const_func __attribute__((overloadable)) ldexp(float16 x, int n);
double const_func __attribute__((overloadable)) ldexp(double x, int n);
double2 const_func __attribute__((overloadable)) ldexp(double2 x, int2 n);
double3 const_func __attribute__((overloadable)) ldexp(double3 x, int3 n);
double4 const_func __attribute__((overloadable)) ldexp(double4 x, int4 n);
double8 const_func __attribute__((overloadable)) ldexp(double8 x, int8 n);
double16 const_func __attribute__((overloadable)) ldexp(double16 x, int16 n);
double2 const_func __attribute__((overloadable)) ldexp(double2 x, int n);
double3 const_func __attribute__((overloadable)) ldexp(double3 x, int n);
double4 const_func __attribute__((overloadable)) ldexp(double4 x, int n);
double8 const_func __attribute__((overloadable)) ldexp(double8 x, int n);
double16 const_func __attribute__((overloadable)) ldexp(double16 x, int n);
//half const_func __attribute__((overloadable)) ldexp(half x, int n);
//half2 const_func __attribute__((overloadable)) ldexp(half2 x, int2 n);
//half3 const_func __attribute__((overloadable)) ldexp(half3 x, int3 n);
//half4 const_func __attribute__((overloadable)) ldexp(half4 x, int4 n);
//half8 const_func __attribute__((overloadable)) ldexp(half8 x, int8 n);
//half16 const_func __attribute__((overloadable)) ldexp(half16 x, int16 n);
//half const_func __attribute__((overloadable)) ldexp(half x, int n);
//half2 const_func __attribute__((overloadable)) ldexp(half2 x, int n);
//half3 const_func __attribute__((overloadable)) ldexp(half3 x, int n);
//half4 const_func __attribute__((overloadable)) ldexp(half4 x, int n);
//half8 const_func __attribute__((overloadable)) ldexp(half8 x, int n);
//half16 const_func __attribute__((overloadable)) ldexp(half16 x, int n);
/**
* Log gamma function. Returns the natural
* logarithm of the absolute value of the gamma
* function. The sign of the gamma function is
* returned in the signp argument of lgamma_r.
*/
float const_func __attribute__((overloadable)) lgamma(float x);
float2 const_func __attribute__((overloadable)) lgamma(float2 x);
float3 const_func __attribute__((overloadable)) lgamma(float3 x);
float4 const_func __attribute__((overloadable)) lgamma(float4 x);
float8 const_func __attribute__((overloadable)) lgamma(float8 x);
float16 const_func __attribute__((overloadable)) lgamma(float16 x);
double const_func __attribute__((overloadable)) lgamma(double x);
double2 const_func __attribute__((overloadable)) lgamma(double2 x);
double3 const_func __attribute__((overloadable)) lgamma(double3 x);
double4 const_func __attribute__((overloadable)) lgamma(double4 x);
double8 const_func __attribute__((overloadable)) lgamma(double8 x);
double16 const_func __attribute__((overloadable)) lgamma(double16 x);
//half const_func __attribute__((overloadable)) lgamma(half x);
//half2 const_func __attribute__((overloadable)) lgamma(half2 x);
//half3 const_func __attribute__((overloadable)) lgamma(half3 x);
//half4 const_func __attribute__((overloadable)) lgamma(half4 x);
//half8 const_func __attribute__((overloadable)) lgamma(half8 x);
//half16 const_func __attribute__((overloadable)) lgamma(half16 x);
float __attribute__((overloadable)) lgamma_r(float x, __global int *signp);
float2 __attribute__((overloadable)) lgamma_r(float2 x, __global int2 *signp);
float3 __attribute__((overloadable)) lgamma_r(float3 x, __global int3 *signp);
float4 __attribute__((overloadable)) lgamma_r(float4 x, __global int4 *signp);
float8 __attribute__((overloadable)) lgamma_r(float8 x, __global int8 *signp);
float16 __attribute__((overloadable)) lgamma_r(float16 x, __global int16 *signp);
float __attribute__((overloadable)) lgamma_r(float x, __local int *signp);
float2 __attribute__((overloadable)) lgamma_r(float2 x, __local int2 *signp);
float3 __attribute__((overloadable)) lgamma_r(float3 x, __local int3 *signp);
float4 __attribute__((overloadable)) lgamma_r(float4 x, __local int4 *signp);
float8 __attribute__((overloadable)) lgamma_r(float8 x, __local int8 *signp);
float16 __attribute__((overloadable)) lgamma_r(float16 x, __local int16 *signp);
float __attribute__((overloadable)) lgamma_r(float x, __private int *signp);
float2 __attribute__((overloadable)) lgamma_r(float2 x, __private int2 *signp);
float3 __attribute__((overloadable)) lgamma_r(float3 x, __private int3 *signp);
float4 __attribute__((overloadable)) lgamma_r(float4 x, __private int4 *signp);
float8 __attribute__((overloadable)) lgamma_r(float8 x, __private int8 *signp);
float16 __attribute__((overloadable)) lgamma_r(float16 x, __private int16 *signp);
double __attribute__((overloadable)) lgamma_r(double x, __global int *signp);
double2 __attribute__((overloadable)) lgamma_r(double2 x, __global int2 *signp);
double3 __attribute__((overloadable)) lgamma_r(double3 x, __global int3 *signp);
double4 __attribute__((overloadable)) lgamma_r(double4 x, __global int4 *signp);
double8 __attribute__((overloadable)) lgamma_r(double8 x, __global int8 *signp);
double16 __attribute__((overloadable)) lgamma_r(double16 x, __global int16 *signp);
double __attribute__((overloadable)) lgamma_r(double x, __local int *signp);
double2 __attribute__((overloadable)) lgamma_r(double2 x, __local int2 *signp);
double3 __attribute__((overloadable)) lgamma_r(double3 x, __local int3 *signp);
double4 __attribute__((overloadable)) lgamma_r(double4 x, __local int4 *signp);
double8 __attribute__((overloadable)) lgamma_r(double8 x, __local int8 *signp);
double16 __attribute__((overloadable)) lgamma_r(double16 x, __local int16 *signp);
double __attribute__((overloadable)) lgamma_r(double x, __private int *signp);
double2 __attribute__((overloadable)) lgamma_r(double2 x, __private int2 *signp);
double3 __attribute__((overloadable)) lgamma_r(double3 x, __private int3 *signp);
double4 __attribute__((overloadable)) lgamma_r(double4 x, __private int4 *signp);
double8 __attribute__((overloadable)) lgamma_r(double8 x, __private int8 *signp);
double16 __attribute__((overloadable)) lgamma_r(double16 x, __private int16 *signp);
//half __attribute__((overloadable)) lgamma_r(half x, __global int *signp);
//half2 __attribute__((overloadable)) lgamma_r(half2 x, __global int2 *signp);
//half3 __attribute__((overloadable)) lgamma_r(half3 x, __global int3 *signp);
//half4 __attribute__((overloadable)) lgamma_r(half4 x, __global int4 *signp);
//half8 __attribute__((overloadable)) lgamma_r(half8 x, __global int8 *signp);
//half16 __attribute__((overloadable)) lgamma_r(half16 x, __global int16 *signp);
//half __attribute__((overloadable)) lgamma_r(half x, __local int *signp);
//half2 __attribute__((overloadable)) lgamma_r(half2 x, __local int2 *signp);
//half3 __attribute__((overloadable)) lgamma_r(half3 x, __local int3 *signp);
//half4 __attribute__((overloadable)) lgamma_r(half4 x, __local int4 *signp);
//half8 __attribute__((overloadable)) lgamma_r(half8 x, __local int8 *signp);
//half16 __attribute__((overloadable)) lgamma_r(half16 x, __local int16 *signp);
//half __attribute__((overloadable)) lgamma_r(half x, __private int *signp);
//half2 __attribute__((overloadable)) lgamma_r(half2 x, __private int2 *signp);
//half3 __attribute__((overloadable)) lgamma_r(half3 x, __private int3 *signp);
//half4 __attribute__((overloadable)) lgamma_r(half4 x, __private int4 *signp);
//half8 __attribute__((overloadable)) lgamma_r(half8 x, __private int8 *signp);
//half16 __attribute__((overloadable)) lgamma_r(half16 x, __private int16 *signp);
/**
* Compute natural logarithm.
*/
float const_func __attribute__((overloadable)) log(float);
float2 const_func __attribute__((overloadable)) log(float2);
float3 const_func __attribute__((overloadable)) log(float3);
float4 const_func __attribute__((overloadable)) log(float4);
float8 const_func __attribute__((overloadable)) log(float8);
float16 const_func __attribute__((overloadable)) log(float16);
double const_func __attribute__((overloadable)) log(double);
double2 const_func __attribute__((overloadable)) log(double2);
double3 const_func __attribute__((overloadable)) log(double3);
double4 const_func __attribute__((overloadable)) log(double4);
double8 const_func __attribute__((overloadable)) log(double8);
double16 const_func __attribute__((overloadable)) log(double16);
//half const_func __attribute__((overloadable)) log(half);
//half2 const_func __attribute__((overloadable)) log(half2);
//half3 const_func __attribute__((overloadable)) log(half3);
//half4 const_func __attribute__((overloadable)) log(half4);
//half8 const_func __attribute__((overloadable)) log(half8);
//half16 const_func __attribute__((overloadable)) log(half16);
/**
* Compute a base 2 logarithm.
*/
float const_func __attribute__((overloadable)) log2(float);
float2 const_func __attribute__((overloadable)) log2(float2);
float3 const_func __attribute__((overloadable)) log2(float3);
float4 const_func __attribute__((overloadable)) log2(float4);
float8 const_func __attribute__((overloadable)) log2(float8);
float16 const_func __attribute__((overloadable)) log2(float16);
double const_func __attribute__((overloadable)) log2(double);
double2 const_func __attribute__((overloadable)) log2(double2);
double3 const_func __attribute__((overloadable)) log2(double3);
double4 const_func __attribute__((overloadable)) log2(double4);
double8 const_func __attribute__((overloadable)) log2(double8);
double16 const_func __attribute__((overloadable)) log2(double16);
//half const_func __attribute__((overloadable)) log2(half);
//half2 const_func __attribute__((overloadable)) log2(half2);
//half3 const_func __attribute__((overloadable)) log2(half3);
//half4 const_func __attribute__((overloadable)) log2(half4);
//half8 const_func __attribute__((overloadable)) log2(half8);
//half16 const_func __attribute__((overloadable)) log2(half16);
/**
* Compute a base 10 logarithm.
*/
float const_func __attribute__((overloadable)) log10(float);
float2 const_func __attribute__((overloadable)) log10(float2);
float3 const_func __attribute__((overloadable)) log10(float3);
float4 const_func __attribute__((overloadable)) log10(float4);
float8 const_func __attribute__((overloadable)) log10(float8);
float16 const_func __attribute__((overloadable)) log10(float16);
double const_func __attribute__((overloadable)) log10(double);
double2 const_func __attribute__((overloadable)) log10(double2);
double3 const_func __attribute__((overloadable)) log10(double3);
double4 const_func __attribute__((overloadable)) log10(double4);
double8 const_func __attribute__((overloadable)) log10(double8);
double16 const_func __attribute__((overloadable)) log10(double16);
//half const_func __attribute__((overloadable)) log10(half);
//half2 const_func __attribute__((overloadable)) log10(half2);
//half3 const_func __attribute__((overloadable)) log10(half3);
//half4 const_func __attribute__((overloadable)) log10(half4);
//half8 const_func __attribute__((overloadable)) log10(half8);
//half16 const_func __attribute__((overloadable)) log10(half16);
/**
* Compute a base e logarithm of (1.0 + x).
*/
float const_func __attribute__((overloadable)) log1p(float x);
float2 const_func __attribute__((overloadable)) log1p(float2 x);
float3 const_func __attribute__((overloadable)) log1p(float3 x);
float4 const_func __attribute__((overloadable)) log1p(float4 x);
float8 const_func __attribute__((overloadable)) log1p(float8 x);
float16 const_func __attribute__((overloadable)) log1p(float16 x);
double const_func __attribute__((overloadable)) log1p(double x);
double2 const_func __attribute__((overloadable)) log1p(double2 x);
double3 const_func __attribute__((overloadable)) log1p(double3 x);
double4 const_func __attribute__((overloadable)) log1p(double4 x);
double8 const_func __attribute__((overloadable)) log1p(double8 x);
double16 const_func __attribute__((overloadable)) log1p(double16 x);
//half const_func __attribute__((overloadable)) log1p(half x);
//half2 const_func __attribute__((overloadable)) log1p(half2 x);
//half3 const_func __attribute__((overloadable)) log1p(half3 x);
//half4 const_func __attribute__((overloadable)) log1p(half4 x);
//half8 const_func __attribute__((overloadable)) log1p(half8 x);
//half16 const_func __attribute__((overloadable)) log1p(half16 x);
/**
* Compute the exponent of x, which is the integral
* part of logr | x |.
*/
float const_func __attribute__((overloadable)) logb(float x);
float2 const_func __attribute__((overloadable)) logb(float2 x);
float3 const_func __attribute__((overloadable)) logb(float3 x);
float4 const_func __attribute__((overloadable)) logb(float4 x);
float8 const_func __attribute__((overloadable)) logb(float8 x);
float16 const_func __attribute__((overloadable)) logb(float16 x);
double const_func __attribute__((overloadable)) logb(double x);
double2 const_func __attribute__((overloadable)) logb(double2 x);
double3 const_func __attribute__((overloadable)) logb(double3 x);
double4 const_func __attribute__((overloadable)) logb(double4 x);
double8 const_func __attribute__((overloadable)) logb(double8 x);
double16 const_func __attribute__((overloadable)) logb(double16 x);
//half const_func __attribute__((overloadable)) logb(half x);
//half2 const_func __attribute__((overloadable)) logb(half2 x);
//half3 const_func __attribute__((overloadable)) logb(half3 x);
//half4 const_func __attribute__((overloadable)) logb(half4 x);
//half8 const_func __attribute__((overloadable)) logb(half8 x);
//half16 const_func __attribute__((overloadable)) logb(half16 x);
/**
* mad approximates a * b + c. Whether or how the
* product of a * b is rounded and how supernormal or
* subnormal intermediate products are handled is not
* defined. mad is intended to be used where speed is
* preferred over accuracy.
*/
float const_func __attribute__((overloadable)) mad(float a, float b, float c);
float2 const_func __attribute__((overloadable)) mad(float2 a, float2 b, float2 c);
float3 const_func __attribute__((overloadable)) mad(float3 a, float3 b, float3 c);
float4 const_func __attribute__((overloadable)) mad(float4 a, float4 b, float4 c);
float8 const_func __attribute__((overloadable)) mad(float8 a, float8 b, float8 c);
float16 const_func __attribute__((overloadable)) mad(float16 a, float16 b, float16 c);
double const_func __attribute__((overloadable)) mad(double a, double b, double c);
double2 const_func __attribute__((overloadable)) mad(double2 a, double2 b, double2 c);
double3 const_func __attribute__((overloadable)) mad(double3 a, double3 b, double3 c);
double4 const_func __attribute__((overloadable)) mad(double4 a, double4 b, double4 c);
double8 const_func __attribute__((overloadable)) mad(double8 a, double8 b, double8 c);
double16 const_func __attribute__((overloadable)) mad(double16 a, double16 b, double16 c);
//half const_func __attribute__((overloadable)) mad(half a, half b, half c);
//half2 const_func __attribute__((overloadable)) mad(half2 a, half2 b, half2 c);
//half3 const_func __attribute__((overloadable)) mad(half3 a, half3 b, half3 c);
//half4 const_func __attribute__((overloadable)) mad(half4 a, half4 b, half4 c);
//half8 const_func __attribute__((overloadable)) mad(half8 a, half8 b, half8 c);
//half16 const_func __attribute__((overloadable)) mad(half16 a, half16 b, half16 c);
/**
* Returns x if | x | > | y |, y if | y | > | x |, otherwise
* fmax(x, y).
*/
float const_func __attribute__((overloadable)) maxmag(float x, float y);
float2 const_func __attribute__((overloadable)) maxmag(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) maxmag(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) maxmag(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) maxmag(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) maxmag(float16 x, float16 y);
double const_func __attribute__((overloadable)) maxmag(double x, double y);
double2 const_func __attribute__((overloadable)) maxmag(double2 x, double2 y);
double3 const_func __attribute__((overloadable)) maxmag(double3 x, double3 y);
double4 const_func __attribute__((overloadable)) maxmag(double4 x, double4 y);
double8 const_func __attribute__((overloadable)) maxmag(double8 x, double8 y);
double16 const_func __attribute__((overloadable)) maxmag(double16 x, double16 y);
//half const_func __attribute__((overloadable)) maxmag(half x, half y);
//half2 const_func __attribute__((overloadable)) maxmag(half2 x, half2 y);
//half3 const_func __attribute__((overloadable)) maxmag(half3 x, half3 y);
//half4 const_func __attribute__((overloadable)) maxmag(half4 x, half4 y);
//half8 const_func __attribute__((overloadable)) maxmag(half8 x, half8 y);
//half16 const_func __attribute__((overloadable)) maxmag(half16 x, half16 y);
/**
* Returns x if | x | < | y |, y if | y | < | x |, otherwise
* fmin(x, y).
*/
float const_func __attribute__((overloadable)) minmag(float x, float y);
float2 const_func __attribute__((overloadable)) minmag(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) minmag(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) minmag(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) minmag(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) minmag(float16 x, float16 y);
double const_func __attribute__((overloadable)) minmag(double x, double y);
double2 const_func __attribute__((overloadable)) minmag(double2 x, double2 y);
double3 const_func __attribute__((overloadable)) minmag(double3 x, double3 y);
double4 const_func __attribute__((overloadable)) minmag(double4 x, double4 y);
double8 const_func __attribute__((overloadable)) minmag(double8 x, double8 y);
double16 const_func __attribute__((overloadable)) minmag(double16 x, double16 y);
//half const_func __attribute__((overloadable)) minmag(half x, half y);
//half2 const_func __attribute__((overloadable)) minmag(half2 x, half2 y);
//half3 const_func __attribute__((overloadable)) minmag(half3 x, half3 y);
//half4 const_func __attribute__((overloadable)) minmag(half4 x, half4 y);
//half8 const_func __attribute__((overloadable)) minmag(half8 x, half8 y);
//half16 const_func __attribute__((overloadable)) minmag(half16 x, half16 y);
/**
* Decompose a floating-point number. The modf
* function breaks the argument x into integral and
* fractional parts, each of which has the same sign as
* the argument. It stores the integral part in the object
* pointed to by iptr.
*/
float __attribute__((overloadable)) modf(float x, __global float *iptr);
float2 __attribute__((overloadable)) modf(float2 x, __global float2 *iptr);
float3 __attribute__((overloadable)) modf(float3 x, __global float3 *iptr);
float4 __attribute__((overloadable)) modf(float4 x, __global float4 *iptr);
float8 __attribute__((overloadable)) modf(float8 x, __global float8 *iptr);
float16 __attribute__((overloadable)) modf(float16 x, __global float16 *iptr);
float __attribute__((overloadable)) modf(float x, __local float *iptr);
float2 __attribute__((overloadable)) modf(float2 x, __local float2 *iptr);
float3 __attribute__((overloadable)) modf(float3 x, __local float3 *iptr);
float4 __attribute__((overloadable)) modf(float4 x, __local float4 *iptr);
float8 __attribute__((overloadable)) modf(float8 x, __local float8 *iptr);
float16 __attribute__((overloadable)) modf(float16 x, __local float16 *iptr);
float __attribute__((overloadable)) modf(float x, __private float *iptr);
float2 __attribute__((overloadable)) modf(float2 x, __private float2 *iptr);
float3 __attribute__((overloadable)) modf(float3 x, __private float3 *iptr);
float4 __attribute__((overloadable)) modf(float4 x, __private float4 *iptr);
float8 __attribute__((overloadable)) modf(float8 x, __private float8 *iptr);
float16 __attribute__((overloadable)) modf(float16 x, __private float16 *iptr);
double __attribute__((overloadable)) modf(double x, __global double *iptr);
double2 __attribute__((overloadable)) modf(double2 x, __global double2 *iptr);
double3 __attribute__((overloadable)) modf(double3 x, __global double3 *iptr);
double4 __attribute__((overloadable)) modf(double4 x, __global double4 *iptr);
double8 __attribute__((overloadable)) modf(double8 x, __global double8 *iptr);
double16 __attribute__((overloadable)) modf(double16 x, __global double16 *iptr);
double __attribute__((overloadable)) modf(double x, __local double *iptr);
double2 __attribute__((overloadable)) modf(double2 x, __local double2 *iptr);
double3 __attribute__((overloadable)) modf(double3 x, __local double3 *iptr);
double4 __attribute__((overloadable)) modf(double4 x, __local double4 *iptr);
double8 __attribute__((overloadable)) modf(double8 x, __local double8 *iptr);
double16 __attribute__((overloadable)) modf(double16 x, __local double16 *iptr);
double __attribute__((overloadable)) modf(double x, __private double *iptr);
double2 __attribute__((overloadable)) modf(double2 x, __private double2 *iptr);
double3 __attribute__((overloadable)) modf(double3 x, __private double3 *iptr);
double4 __attribute__((overloadable)) modf(double4 x, __private double4 *iptr);
double8 __attribute__((overloadable)) modf(double8 x, __private double8 *iptr);
double16 __attribute__((overloadable)) modf(double16 x, __private double16 *iptr);
//half __attribute__((overloadable)) modf(half x, __global half *iptr);
//half2 __attribute__((overloadable)) modf(half2 x, __global half2 *iptr);
//half3 __attribute__((overloadable)) modf(half3 x, __global half3 *iptr);
//half4 __attribute__((overloadable)) modf(half4 x, __global half4 *iptr);
//half8 __attribute__((overloadable)) modf(half8 x, __global half8 *iptr);
//half16 __attribute__((overloadable)) modf(half16 x, __global half16 *iptr);
//half __attribute__((overloadable)) modf(half x, __local half *iptr);
//half2 __attribute__((overloadable)) modf(half2 x, __local half2 *iptr);
//half3 __attribute__((overloadable)) modf(half3 x, __local half3 *iptr);
//half4 __attribute__((overloadable)) modf(half4 x, __local half4 *iptr);
//half8 __attribute__((overloadable)) modf(half8 x, __local half8 *iptr);
//half16 __attribute__((overloadable)) modf(half16 x, __local half16 *iptr);
//half __attribute__((overloadable)) modf(half x, __private half *iptr);
//half2 __attribute__((overloadable)) modf(half2 x, __private half2 *iptr);
//half3 __attribute__((overloadable)) modf(half3 x, __private half3 *iptr);
//half4 __attribute__((overloadable)) modf(half4 x, __private half4 *iptr);
//half8 __attribute__((overloadable)) modf(half8 x, __private half8 *iptr);
//half16 __attribute__((overloadable)) modf(half16 x, __private half16 *iptr);
/**
* Returns a quiet NaN. The nancode may be placed
* in the significand of the resulting NaN.
*/
float const_func __attribute__((overloadable)) nan(uint nancode);
float2 const_func __attribute__((overloadable)) nan(uint2 nancode);
float3 const_func __attribute__((overloadable)) nan(uint3 nancode);
float4 const_func __attribute__((overloadable)) nan(uint4 nancode);
float8 const_func __attribute__((overloadable)) nan(uint8 nancode);
float16 const_func __attribute__((overloadable)) nan(uint16 nancode);
double const_func __attribute__((overloadable)) nan(ulong nancode);
double2 const_func __attribute__((overloadable)) nan(ulong2 nancode);
double3 const_func __attribute__((overloadable)) nan(ulong3 nancode);
double4 const_func __attribute__((overloadable)) nan(ulong4 nancode);
double8 const_func __attribute__((overloadable)) nan(ulong8 nancode);
double16 const_func __attribute__((overloadable)) nan(ulong16 nancode);
//half const_func __attribute__((overloadable)) nan(ushort nancode);
//half2 const_func __attribute__((overloadable)) nan(ushort2 nancode);
//half3 const_func __attribute__((overloadable)) nan(ushort3 nancode);
//half4 const_func __attribute__((overloadable)) nan(ushort4 nancode);
//half8 const_func __attribute__((overloadable)) nan(ushort8 nancode);
//half16 const_func __attribute__((overloadable)) nan(ushort16 nancode);
/**
* Computes the next representable single-precision
* floating-point value following x in the direction of
* y. Thus, if y is less than x, nextafter() returns the
* largest representable floating-point number less
* than x.
*/
float const_func __attribute__((overloadable)) nextafter(float x, float y);
float2 const_func __attribute__((overloadable)) nextafter(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) nextafter(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) nextafter(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) nextafter(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) nextafter(float16 x, float16 y);
double const_func __attribute__((overloadable)) nextafter(double x, double y);
double2 const_func __attribute__((overloadable)) nextafter(double2 x, double2 y);
double3 const_func __attribute__((overloadable)) nextafter(double3 x, double3 y);
double4 const_func __attribute__((overloadable)) nextafter(double4 x, double4 y);
double8 const_func __attribute__((overloadable)) nextafter(double8 x, double8 y);
double16 const_func __attribute__((overloadable)) nextafter(double16 x, double16 y);
//half const_func __attribute__((overloadable)) nextafter(half x, half y);
//half2 const_func __attribute__((overloadable)) nextafter(half2 x, half2 y);
//half3 const_func __attribute__((overloadable)) nextafter(half3 x, half3 y);
//half4 const_func __attribute__((overloadable)) nextafter(half4 x, half4 y);
//half8 const_func __attribute__((overloadable)) nextafter(half8 x, half8 y);
//half16 const_func __attribute__((overloadable)) nextafter(half16 x, half16 y);
/**
* Compute x to the power y.
*/
double const_func __attribute__((overloadable)) pow(double x, double y);
double2 const_func __attribute__((overloadable)) pow(double2 x, double2 y);
double3 const_func __attribute__((overloadable)) pow(double3 x, double3 y);
double4 const_func __attribute__((overloadable)) pow(double4 x, double4 y);
double8 const_func __attribute__((overloadable)) pow(double8 x, double8 y);
double16 const_func __attribute__((overloadable)) pow(double16 x, double16 y);
float const_func __attribute__((overloadable)) pow(float x, float y);
float2 const_func __attribute__((overloadable)) pow(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) pow(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) pow(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) pow(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) pow(float16 x, float16 y);
//half const_func __attribute__((overloadable)) pow(half x, half y);
//half2 const_func __attribute__((overloadable)) pow(half2 x, half2 y);
//half3 const_func __attribute__((overloadable)) pow(half3 x, half3 y);
//half4 const_func __attribute__((overloadable)) pow(half4 x, half4 y);
//half8 const_func __attribute__((overloadable)) pow(half8 x, half8 y);
//half16 const_func __attribute__((overloadable)) pow(half16 x, half16 y);
/**
* Compute x to the power y, where y is an integer.
*/
float const_func __attribute__((overloadable)) pown(float x, int y);
float2 const_func __attribute__((overloadable)) pown(float2 x, int2 y);
float3 const_func __attribute__((overloadable)) pown(float3 x, int3 y);
float4 const_func __attribute__((overloadable)) pown(float4 x, int4 y);
float8 const_func __attribute__((overloadable)) pown(float8 x, int8 y);
float16 const_func __attribute__((overloadable)) pown(float16 x, int16 y);
double const_func __attribute__((overloadable)) pown(double x, int y);
double2 const_func __attribute__((overloadable)) pown(double2 x, int2 y);
double3 const_func __attribute__((overloadable)) pown(double3 x, int3 y);
double4 const_func __attribute__((overloadable)) pown(double4 x, int4 y);
double8 const_func __attribute__((overloadable)) pown(double8 x, int8 y);
double16 const_func __attribute__((overloadable)) pown(double16 x, int16 y);
//half const_func __attribute__((overloadable)) pown(half x, int y);
//half2 const_func __attribute__((overloadable)) pown(half2 x, int2 y);
//half3 const_func __attribute__((overloadable)) pown(half3 x, int3 y);
//half4 const_func __attribute__((overloadable)) pown(half4 x, int4 y);
//half8 const_func __attribute__((overloadable)) pown(half8 x, int8 y);
//half16 const_func __attribute__((overloadable)) pown(half16 x, int16 y);
/**
* Compute x to the power y, where x is >= 0.
*/
float const_func __attribute__((overloadable)) powr(float x, float y);
float2 const_func __attribute__((overloadable)) powr(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) powr(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) powr(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) powr(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) powr(float16 x, float16 y);
double const_func __attribute__((overloadable)) powr(double x, double y);
double2 const_func __attribute__((overloadable)) powr(double2 x, double2 y);
double3 const_func __attribute__((overloadable)) powr(double3 x, double3 y);
double4 const_func __attribute__((overloadable)) powr(double4 x, double4 y);
double8 const_func __attribute__((overloadable)) powr(double8 x, double8 y);
double16 const_func __attribute__((overloadable)) powr(double16 x, double16 y);
//half const_func __attribute__((overloadable)) powr(half x, half y);
//half2 const_func __attribute__((overloadable)) powr(half2 x, half2 y);
//half3 const_func __attribute__((overloadable)) powr(half3 x, half3 y);
//half4 const_func __attribute__((overloadable)) powr(half4 x, half4 y);
//half8 const_func __attribute__((overloadable)) powr(half8 x, half8 y);
//half16 const_func __attribute__((overloadable)) powr(half16 x, half16 y);
/**
* Compute the value r such that r = x - n*y, where n
* is the integer nearest the exact value of x/y. If there
* are two integers closest to x/y, n shall be the even
* one. If r is zero, it is given the same sign as x.
*/
float const_func __attribute__((overloadable)) remainder(float x, float y);
float2 const_func __attribute__((overloadable)) remainder(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) remainder(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) remainder(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) remainder(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) remainder(float16 x, float16 y);
double const_func __attribute__((overloadable)) remainder(double x, double y);
double2 const_func __attribute__((overloadable)) remainder(double2 x, double2 y);
double3 const_func __attribute__((overloadable)) remainder(double3 x, double3 y);
double4 const_func __attribute__((overloadable)) remainder(double4 x, double4 y);
double8 const_func __attribute__((overloadable)) remainder(double8 x, double8 y);
double16 const_func __attribute__((overloadable)) remainder(double16 x, double16 y);
//half const_func __attribute__((overloadable)) remainder(half x, half y);
//half2 const_func __attribute__((overloadable)) remainder(half2 x, half2 y);
//half3 const_func __attribute__((overloadable)) remainder(half3 x, half3 y);
//half4 const_func __attribute__((overloadable)) remainder(half4 x, half4 y);
//half8 const_func __attribute__((overloadable)) remainder(half8 x, half8 y);
//half16 const_func __attribute__((overloadable)) remainder(half16 x, half16 y);
/**
* The remquo function computes the value r such
* that r = x - n*y, where n is the integer nearest the
* exact value of x/y. If there are two integers closest
* to x/y, n shall be the even one. If r is zero, it is
* given the same sign as x. This is the same value
* that is returned by the remainder function.
* remquo also calculates the lower seven bits of the
* integral quotient x/y, and gives that value the same
* sign as x/y. It stores this signed value in the object
* pointed to by quo.
*/
float __attribute__((overloadable)) remquo(float x, float y, __global int *quo);
float2 __attribute__((overloadable)) remquo(float2 x, float2 y, __global int2 *quo);
float3 __attribute__((overloadable)) remquo(float3 x, float3 y, __global int3 *quo);
float4 __attribute__((overloadable)) remquo(float4 x, float4 y, __global int4 *quo);
float8 __attribute__((overloadable)) remquo(float8 x, float8 y, __global int8 *quo);
float16 __attribute__((overloadable)) remquo(float16 x, float16 y, __global int16 *quo);
float __attribute__((overloadable)) remquo(float x, float y, __local int *quo);
float2 __attribute__((overloadable)) remquo(float2 x, float2 y, __local int2 *quo);
float3 __attribute__((overloadable)) remquo(float3 x, float3 y, __local int3 *quo);
float4 __attribute__((overloadable)) remquo(float4 x, float4 y, __local int4 *quo);
float8 __attribute__((overloadable)) remquo(float8 x, float8 y, __local int8 *quo);
float16 __attribute__((overloadable)) remquo(float16 x, float16 y, __local int16 *quo);
float __attribute__((overloadable)) remquo(float x, float y, __private int *quo);
float2 __attribute__((overloadable)) remquo(float2 x, float2 y, __private int2 *quo);
float3 __attribute__((overloadable)) remquo(float3 x, float3 y, __private int3 *quo);
float4 __attribute__((overloadable)) remquo(float4 x, float4 y, __private int4 *quo);
float8 __attribute__((overloadable)) remquo(float8 x, float8 y, __private int8 *quo);
float16 __attribute__((overloadable)) remquo(float16 x, float16 y, __private int16 *quo);
double __attribute__((overloadable)) remquo(double x, double y, __global int *quo);
double2 __attribute__((overloadable)) remquo(double2 x, double2 y, __global int2 *quo);
double3 __attribute__((overloadable)) remquo(double3 x, double3 y, __global int3 *quo);
double4 __attribute__((overloadable)) remquo(double4 x, double4 y, __global int4 *quo);
double8 __attribute__((overloadable)) remquo(double8 x, double8 y, __global int8 *quo);
double16 __attribute__((overloadable)) remquo(double16 x, double16 y, __global int16 *quo);
double __attribute__((overloadable)) remquo(double x, double y, __local int *quo);
double2 __attribute__((overloadable)) remquo(double2 x, double2 y, __local int2 *quo);
double3 __attribute__((overloadable)) remquo(double3 x, double3 y, __local int3 *quo);
double4 __attribute__((overloadable)) remquo(double4 x, double4 y, __local int4 *quo);
double8 __attribute__((overloadable)) remquo(double8 x, double8 y, __local int8 *quo);
double16 __attribute__((overloadable)) remquo(double16 x, double16 y, __local int16 *quo);
double __attribute__((overloadable)) remquo(double x, double y, __private int *quo);
double2 __attribute__((overloadable)) remquo(double2 x, double2 y, __private int2 *quo);
double3 __attribute__((overloadable)) remquo(double3 x, double3 y, __private int3 *quo);
double4 __attribute__((overloadable)) remquo(double4 x, double4 y, __private int4 *quo);
double8 __attribute__((overloadable)) remquo(double8 x, double8 y, __private int8 *quo);
double16 __attribute__((overloadable)) remquo(double16 x, double16 y, __private int16 *quo);
//half __attribute__((overloadable)) remquo(half x, half y, __global int *quo);
//half2 __attribute__((overloadable)) remquo(half2 x, half2 y, __global int2 *quo);
//half3 __attribute__((overloadable)) remquo(half3 x, half3 y, __global int3 *quo);
//half4 __attribute__((overloadable)) remquo(half4 x, half4 y, __global int4 *quo);
//half8 __attribute__((overloadable)) remquo(half8 x, half8 y, __global int8 *quo);
//half16 __attribute__((overloadable)) remquo(half16 x, half16 y, __global int16 *quo);
//half __attribute__((overloadable)) remquo(half x, half y, __local int *quo);
//half2 __attribute__((overloadable)) remquo(half2 x, half2 y, __local int2 *quo);
//half3 __attribute__((overloadable)) remquo(half3 x, half3 y, __local int3 *quo);
//half4 __attribute__((overloadable)) remquo(half4 x, half4 y, __local int4 *quo);
//half8 __attribute__((overloadable)) remquo(half8 x, half8 y, __local int8 *quo);
//half16 __attribute__((overloadable)) remquo(half16 x, half16 y, __local int16 *quo);
//half __attribute__((overloadable)) remquo(half x, half y, __private int *quo);
//half2 __attribute__((overloadable)) remquo(half2 x, half2 y, __private int2 *quo);
//half3 __attribute__((overloadable)) remquo(half3 x, half3 y, __private int3 *quo);
//half4 __attribute__((overloadable)) remquo(half4 x, half4 y, __private int4 *quo);
//half8 __attribute__((overloadable)) remquo(half8 x, half8 y, __private int8 *quo);
//half16 __attribute__((overloadable)) remquo(half16 x, half16 y, __private int16 *quo);
/**
* Round to integral value (using round to nearest
* even rounding mode) in floating-point format.
* Refer to section 7.1 for description of rounding
* modes.
*/
float const_func __attribute__((overloadable)) rint(float);
float2 const_func __attribute__((overloadable)) rint(float2);
float3 const_func __attribute__((overloadable)) rint(float3);
float4 const_func __attribute__((overloadable)) rint(float4);
float8 const_func __attribute__((overloadable)) rint(float8);
float16 const_func __attribute__((overloadable)) rint(float16);
double const_func __attribute__((overloadable)) rint(double);
double2 const_func __attribute__((overloadable)) rint(double2);
double3 const_func __attribute__((overloadable)) rint(double3);
double4 const_func __attribute__((overloadable)) rint(double4);
double8 const_func __attribute__((overloadable)) rint(double8);
double16 const_func __attribute__((overloadable)) rint(double16);
//half const_func __attribute__((overloadable)) rint(half);
//half2 const_func __attribute__((overloadable)) rint(half2);
//half3 const_func __attribute__((overloadable)) rint(half3);
//half4 const_func __attribute__((overloadable)) rint(half4);
//half8 const_func __attribute__((overloadable)) rint(half8);
//half16 const_func __attribute__((overloadable)) rint(half16);
/**
* Compute x to the power 1/y.
*/
float const_func __attribute__((overloadable)) rootn(float x, int y);
float2 const_func __attribute__((overloadable)) rootn(float2 x, int2 y);
float3 const_func __attribute__((overloadable)) rootn(float3 x, int3 y);
float4 const_func __attribute__((overloadable)) rootn(float4 x, int4 y);
float8 const_func __attribute__((overloadable)) rootn(float8 x, int8 y);
float16 const_func __attribute__((overloadable)) rootn(float16 x, int16 y);
double const_func __attribute__((overloadable)) rootn(double x, int y);
double2 const_func __attribute__((overloadable)) rootn(double2 x, int2 y);
double3 const_func __attribute__((overloadable)) rootn(double3 x, int3 y);
double4 const_func __attribute__((overloadable)) rootn(double4 x, int4 y);
double8 const_func __attribute__((overloadable)) rootn(double8 x, int8 y);
double16 const_func __attribute__((overloadable)) rootn(double16 x, int16 y);
//half const_func __attribute__((overloadable)) rootn(half x, int y);
//half2 const_func __attribute__((overloadable)) rootn(half2 x, int2 y);
//half3 const_func __attribute__((overloadable)) rootn(half3 x, int3 y);
//half4 const_func __attribute__((overloadable)) rootn(half4 x, int4 y);
//half8 const_func __attribute__((overloadable)) rootn(half8 x, int8 y);
//half16 const_func __attribute__((overloadable)) rootn(half16 x, int16 y);
/**
* Return the integral value nearest to x rounding
* halfway cases away from zero, regardless of the
* current rounding direction.
*/
float const_func __attribute__((overloadable)) round(float x);
float2 const_func __attribute__((overloadable)) round(float2 x);
float3 const_func __attribute__((overloadable)) round(float3 x);
float4 const_func __attribute__((overloadable)) round(float4 x);
float8 const_func __attribute__((overloadable)) round(float8 x);
float16 const_func __attribute__((overloadable)) round(float16 x);
double const_func __attribute__((overloadable)) round(double x);
double2 const_func __attribute__((overloadable)) round(double2 x);
double3 const_func __attribute__((overloadable)) round(double3 x);
double4 const_func __attribute__((overloadable)) round(double4 x);
double8 const_func __attribute__((overloadable)) round(double8 x);
double16 const_func __attribute__((overloadable)) round(double16 x);
//half const_func __attribute__((overloadable)) round(half x);
//half2 const_func __attribute__((overloadable)) round(half2 x);
//half3 const_func __attribute__((overloadable)) round(half3 x);
//half4 const_func __attribute__((overloadable)) round(half4 x);
//half8 const_func __attribute__((overloadable)) round(half8 x);
//half16 const_func __attribute__((overloadable)) round(half16 x);
/**
* Compute inverse square root.
*/
float const_func __attribute__((overloadable)) rsqrt(float);
float2 const_func __attribute__((overloadable)) rsqrt(float2);
float3 const_func __attribute__((overloadable)) rsqrt(float3);
float4 const_func __attribute__((overloadable)) rsqrt(float4);
float8 const_func __attribute__((overloadable)) rsqrt(float8);
float16 const_func __attribute__((overloadable)) rsqrt(float16);
double const_func __attribute__((overloadable)) rsqrt(double);
double2 const_func __attribute__((overloadable)) rsqrt(double2);
double3 const_func __attribute__((overloadable)) rsqrt(double3);
double4 const_func __attribute__((overloadable)) rsqrt(double4);
double8 const_func __attribute__((overloadable)) rsqrt(double8);
double16 const_func __attribute__((overloadable)) rsqrt(double16);
//half const_func __attribute__((overloadable)) rsqrt(half);
//half2 const_func __attribute__((overloadable)) rsqrt(half2);
//half3 const_func __attribute__((overloadable)) rsqrt(half3);
//half4 const_func __attribute__((overloadable)) rsqrt(half4);
//half8 const_func __attribute__((overloadable)) rsqrt(half8);
//half16 const_func __attribute__((overloadable)) rsqrt(half16);
/**
* Compute sine.
*/
double const_func __attribute__((overloadable)) sin(double);
double2 const_func __attribute__((overloadable)) sin(double2);
double3 const_func __attribute__((overloadable)) sin(double3);
double4 const_func __attribute__((overloadable)) sin(double4);
double8 const_func __attribute__((overloadable)) sin(double8);
double16 const_func __attribute__((overloadable)) sin(double16);
float const_func __attribute__((overloadable)) sin(float);
float2 const_func __attribute__((overloadable)) sin(float2);
float3 const_func __attribute__((overloadable)) sin(float3);
float4 const_func __attribute__((overloadable)) sin(float4);
float8 const_func __attribute__((overloadable)) sin(float8);
float16 const_func __attribute__((overloadable)) sin(float16);
//half const_func __attribute__((overloadable)) sin(half);
//half2 const_func __attribute__((overloadable)) sin(half2);
//half3 const_func __attribute__((overloadable)) sin(half3);
//half4 const_func __attribute__((overloadable)) sin(half4);
//half8 const_func __attribute__((overloadable)) sin(half8);
//half16 const_func __attribute__((overloadable)) sin(half16);
/**
* Compute sine and cosine of x. The computed sine
* is the return value and computed cosine is returned
* in cosval.
*/
float __attribute__((overloadable)) sincos(float x, __global float *cosval);
float2 __attribute__((overloadable)) sincos(float2 x, __global float2 *cosval);
float3 __attribute__((overloadable)) sincos(float3 x, __global float3 *cosval);
float4 __attribute__((overloadable)) sincos(float4 x, __global float4 *cosval);
float8 __attribute__((overloadable)) sincos(float8 x, __global float8 *cosval);
float16 __attribute__((overloadable)) sincos(float16 x, __global float16 *cosval);
float __attribute__((overloadable)) sincos(float x, __local float *cosval);
float2 __attribute__((overloadable)) sincos(float2 x, __local float2 *cosval);
float3 __attribute__((overloadable)) sincos(float3 x, __local float3 *cosval);
float4 __attribute__((overloadable)) sincos(float4 x, __local float4 *cosval);
float8 __attribute__((overloadable)) sincos(float8 x, __local float8 *cosval);
float16 __attribute__((overloadable)) sincos(float16 x, __local float16 *cosval);
float __attribute__((overloadable)) sincos(float x, __private float *cosval);
float2 __attribute__((overloadable)) sincos(float2 x, __private float2 *cosval);
float3 __attribute__((overloadable)) sincos(float3 x, __private float3 *cosval);
float4 __attribute__((overloadable)) sincos(float4 x, __private float4 *cosval);
float8 __attribute__((overloadable)) sincos(float8 x, __private float8 *cosval);
float16 __attribute__((overloadable)) sincos(float16 x, __private float16 *cosval);
double __attribute__((overloadable)) sincos(double x, __global double *cosval);
double2 __attribute__((overloadable)) sincos(double2 x, __global double2 *cosval);
double3 __attribute__((overloadable)) sincos(double3 x, __global double3 *cosval);
double4 __attribute__((overloadable)) sincos(double4 x, __global double4 *cosval);
double8 __attribute__((overloadable)) sincos(double8 x, __global double8 *cosval);
double16 __attribute__((overloadable)) sincos(double16 x, __global double16 *cosval);
double __attribute__((overloadable)) sincos(double x, __local double *cosval);
double2 __attribute__((overloadable)) sincos(double2 x, __local double2 *cosval);
double3 __attribute__((overloadable)) sincos(double3 x, __local double3 *cosval);
double4 __attribute__((overloadable)) sincos(double4 x, __local double4 *cosval);
double8 __attribute__((overloadable)) sincos(double8 x, __local double8 *cosval);
double16 __attribute__((overloadable)) sincos(double16 x, __local double16 *cosval);
double __attribute__((overloadable)) sincos(double x, __private double *cosval);
double2 __attribute__((overloadable)) sincos(double2 x, __private double2 *cosval);
double3 __attribute__((overloadable)) sincos(double3 x, __private double3 *cosval);
double4 __attribute__((overloadable)) sincos(double4 x, __private double4 *cosval);
double8 __attribute__((overloadable)) sincos(double8 x, __private double8 *cosval);
double16 __attribute__((overloadable)) sincos(double16 x, __private double16 *cosval);
//half __attribute__((overloadable)) sincos(half x, __global half *cosval);
//half2 __attribute__((overloadable)) sincos(half2 x, __global half2 *cosval);
//half3 __attribute__((overloadable)) sincos(half3 x, __global half3 *cosval);
//half4 __attribute__((overloadable)) sincos(half4 x, __global half4 *cosval);
//half8 __attribute__((overloadable)) sincos(half8 x, __global half8 *cosval);
//half16 __attribute__((overloadable)) sincos(half16 x, __global half16 *cosval);
//half __attribute__((overloadable)) sincos(half x, __local half *cosval);
//half2 __attribute__((overloadable)) sincos(half2 x, __local half2 *cosval);
//half3 __attribute__((overloadable)) sincos(half3 x, __local half3 *cosval);
//half4 __attribute__((overloadable)) sincos(half4 x, __local half4 *cosval);
//half8 __attribute__((overloadable)) sincos(half8 x, __local half8 *cosval);
//half16 __attribute__((overloadable)) sincos(half16 x, __local half16 *cosval);
//half __attribute__((overloadable)) sincos(half x, __private half *cosval);
//half2 __attribute__((overloadable)) sincos(half2 x, __private half2 *cosval);
//half3 __attribute__((overloadable)) sincos(half3 x, __private half3 *cosval);
//half4 __attribute__((overloadable)) sincos(half4 x, __private half4 *cosval);
//half8 __attribute__((overloadable)) sincos(half8 x, __private half8 *cosval);
//half16 __attribute__((overloadable)) sincos(half16 x, __private half16 *cosval);
/**
* Compute hyperbolic sine.
*/
float const_func __attribute__((overloadable)) sinh(float);
float2 const_func __attribute__((overloadable)) sinh(float2);
float3 const_func __attribute__((overloadable)) sinh(float3);
float4 const_func __attribute__((overloadable)) sinh(float4);
float8 const_func __attribute__((overloadable)) sinh(float8);
float16 const_func __attribute__((overloadable)) sinh(float16);
double const_func __attribute__((overloadable)) sinh(double);
double2 const_func __attribute__((overloadable)) sinh(double2);
double3 const_func __attribute__((overloadable)) sinh(double3);
double4 const_func __attribute__((overloadable)) sinh(double4);
double8 const_func __attribute__((overloadable)) sinh(double8);
double16 const_func __attribute__((overloadable)) sinh(double16);
//half const_func __attribute__((overloadable)) sinh(half);
//half2 const_func __attribute__((overloadable)) sinh(half2);
//half3 const_func __attribute__((overloadable)) sinh(half3);
//half4 const_func __attribute__((overloadable)) sinh(half4);
//half8 const_func __attribute__((overloadable)) sinh(half8);
//half16 const_func __attribute__((overloadable)) sinh(half16);
/**
* Compute sin (PI * x).
*/
float const_func __attribute__((overloadable)) sinpi(float x);
float2 const_func __attribute__((overloadable)) sinpi(float2 x);
float3 const_func __attribute__((overloadable)) sinpi(float3 x);
float4 const_func __attribute__((overloadable)) sinpi(float4 x);
float8 const_func __attribute__((overloadable)) sinpi(float8 x);
float16 const_func __attribute__((overloadable)) sinpi(float16 x);
double const_func __attribute__((overloadable)) sinpi(double x);
double2 const_func __attribute__((overloadable)) sinpi(double2 x);
double3 const_func __attribute__((overloadable)) sinpi(double3 x);
double4 const_func __attribute__((overloadable)) sinpi(double4 x);
double8 const_func __attribute__((overloadable)) sinpi(double8 x);
double16 const_func __attribute__((overloadable)) sinpi(double16 x);
//half const_func __attribute__((overloadable)) sinpi(half x);
//half2 const_func __attribute__((overloadable)) sinpi(half2 x);
//half3 const_func __attribute__((overloadable)) sinpi(half3 x);
//half4 const_func __attribute__((overloadable)) sinpi(half4 x);
//half8 const_func __attribute__((overloadable)) sinpi(half8 x);
//half16 const_func __attribute__((overloadable)) sinpi(half16 x);
/**
* Compute square root.
*/
double const_func __attribute__((overloadable)) sqrt(double);
double2 const_func __attribute__((overloadable)) sqrt(double2);
double3 const_func __attribute__((overloadable)) sqrt(double3);
double4 const_func __attribute__((overloadable)) sqrt(double4);
double8 const_func __attribute__((overloadable)) sqrt(double8);
double16 const_func __attribute__((overloadable)) sqrt(double16);
float const_func __attribute__((overloadable)) sqrt(float);
float2 const_func __attribute__((overloadable)) sqrt(float2);
float3 const_func __attribute__((overloadable)) sqrt(float3);
float4 const_func __attribute__((overloadable)) sqrt(float4);
float8 const_func __attribute__((overloadable)) sqrt(float8);
float16 const_func __attribute__((overloadable)) sqrt(float16);
//half const_func __attribute__((overloadable)) sqrt(half);
//half2 const_func __attribute__((overloadable)) sqrt(half2);
//half3 const_func __attribute__((overloadable)) sqrt(half3);
//half4 const_func __attribute__((overloadable)) sqrt(half4);
//half8 const_func __attribute__((overloadable)) sqrt(half8);
//half16 const_func __attribute__((overloadable)) sqrt(half16);
/**
* Compute tangent.
*/
float const_func __attribute__((overloadable)) tan(float);
float2 const_func __attribute__((overloadable)) tan(float2);
float3 const_func __attribute__((overloadable)) tan(float3);
float4 const_func __attribute__((overloadable)) tan(float4);
float8 const_func __attribute__((overloadable)) tan(float8);
float16 const_func __attribute__((overloadable)) tan(float16);
double const_func __attribute__((overloadable)) tan(double);
double2 const_func __attribute__((overloadable)) tan(double2);
double3 const_func __attribute__((overloadable)) tan(double3);
double4 const_func __attribute__((overloadable)) tan(double4);
double8 const_func __attribute__((overloadable)) tan(double8);
double16 const_func __attribute__((overloadable)) tan(double16);
//half const_func __attribute__((overloadable)) tan(half);
//half2 const_func __attribute__((overloadable)) tan(half2);
//half3 const_func __attribute__((overloadable)) tan(half3);
//half4 const_func __attribute__((overloadable)) tan(half4);
//half8 const_func __attribute__((overloadable)) tan(half8);
//half16 const_func __attribute__((overloadable)) tan(half16);
/**
* Compute hyperbolic tangent.
*/
float const_func __attribute__((overloadable)) tanh(float);
float2 const_func __attribute__((overloadable)) tanh(float2);
float3 const_func __attribute__((overloadable)) tanh(float3);
float4 const_func __attribute__((overloadable)) tanh(float4);
float8 const_func __attribute__((overloadable)) tanh(float8);
float16 const_func __attribute__((overloadable)) tanh(float16);
double const_func __attribute__((overloadable)) tanh(double);
double2 const_func __attribute__((overloadable)) tanh(double2);
double3 const_func __attribute__((overloadable)) tanh(double3);
double4 const_func __attribute__((overloadable)) tanh(double4);
double8 const_func __attribute__((overloadable)) tanh(double8);
double16 const_func __attribute__((overloadable)) tanh(double16);
//half const_func __attribute__((overloadable)) tanh(half);
//half2 const_func __attribute__((overloadable)) tanh(half2);
//half3 const_func __attribute__((overloadable)) tanh(half3);
//half4 const_func __attribute__((overloadable)) tanh(half4);
//half8 const_func __attribute__((overloadable)) tanh(half8);
//half16 const_func __attribute__((overloadable)) tanh(half16);
/**
* Compute tan (PI * x).
*/
float const_func __attribute__((overloadable)) tanpi(float x);
float2 const_func __attribute__((overloadable)) tanpi(float2 x);
float3 const_func __attribute__((overloadable)) tanpi(float3 x);
float4 const_func __attribute__((overloadable)) tanpi(float4 x);
float8 const_func __attribute__((overloadable)) tanpi(float8 x);
float16 const_func __attribute__((overloadable)) tanpi(float16 x);
double const_func __attribute__((overloadable)) tanpi(double x);
double2 const_func __attribute__((overloadable)) tanpi(double2 x);
double3 const_func __attribute__((overloadable)) tanpi(double3 x);
double4 const_func __attribute__((overloadable)) tanpi(double4 x);
double8 const_func __attribute__((overloadable)) tanpi(double8 x);
double16 const_func __attribute__((overloadable)) tanpi(double16 x);
//half const_func __attribute__((overloadable)) tanpi(half x);
//half2 const_func __attribute__((overloadable)) tanpi(half2 x);
//half3 const_func __attribute__((overloadable)) tanpi(half3 x);
//half4 const_func __attribute__((overloadable)) tanpi(half4 x);
//half8 const_func __attribute__((overloadable)) tanpi(half8 x);
//half16 const_func __attribute__((overloadable)) tanpi(half16 x);
/**
* Compute the gamma function.
*/
float const_func __attribute__((overloadable)) tgamma(float);
float2 const_func __attribute__((overloadable)) tgamma(float2);
float3 const_func __attribute__((overloadable)) tgamma(float3);
float4 const_func __attribute__((overloadable)) tgamma(float4);
float8 const_func __attribute__((overloadable)) tgamma(float8);
float16 const_func __attribute__((overloadable)) tgamma(float16);
double const_func __attribute__((overloadable)) tgamma(double);
double2 const_func __attribute__((overloadable)) tgamma(double2);
double3 const_func __attribute__((overloadable)) tgamma(double3);
double4 const_func __attribute__((overloadable)) tgamma(double4);
double8 const_func __attribute__((overloadable)) tgamma(double8);
double16 const_func __attribute__((overloadable)) tgamma(double16);
//half const_func __attribute__((overloadable)) tgamma(half);
//half2 const_func __attribute__((overloadable)) tgamma(half2);
//half3 const_func __attribute__((overloadable)) tgamma(half3);
//half4 const_func __attribute__((overloadable)) tgamma(half4);
//half8 const_func __attribute__((overloadable)) tgamma(half8);
//half16 const_func __attribute__((overloadable)) tgamma(half16);
/**
* Round to integral value using the round to zero
* rounding mode.
*/
float const_func __attribute__((overloadable)) trunc(float);
float2 const_func __attribute__((overloadable)) trunc(float2);
float3 const_func __attribute__((overloadable)) trunc(float3);
float4 const_func __attribute__((overloadable)) trunc(float4);
float8 const_func __attribute__((overloadable)) trunc(float8);
float16 const_func __attribute__((overloadable)) trunc(float16);
double const_func __attribute__((overloadable)) trunc(double);
double2 const_func __attribute__((overloadable)) trunc(double2);
double3 const_func __attribute__((overloadable)) trunc(double3);
double4 const_func __attribute__((overloadable)) trunc(double4);
double8 const_func __attribute__((overloadable)) trunc(double8);
double16 const_func __attribute__((overloadable)) trunc(double16);
//half const_func __attribute__((overloadable)) trunc(half);
//half2 const_func __attribute__((overloadable)) trunc(half2);
//half3 const_func __attribute__((overloadable)) trunc(half3);
//half4 const_func __attribute__((overloadable)) trunc(half4);
//half8 const_func __attribute__((overloadable)) trunc(half8);
//half16 const_func __attribute__((overloadable)) trunc(half16);
/**
* Compute cosine. x must be in the range -2^16 ... +2^16.
*/
float const_func __attribute__((overloadable)) half_cos(float x);
float2 const_func __attribute__((overloadable)) half_cos(float2 x);
float3 const_func __attribute__((overloadable)) half_cos(float3 x);
float4 const_func __attribute__((overloadable)) half_cos(float4 x);
float8 const_func __attribute__((overloadable)) half_cos(float8 x);
float16 const_func __attribute__((overloadable)) half_cos(float16 x);
/**
* Compute x / y.
*/
float const_func __attribute__((overloadable)) half_divide(float x, float y);
float2 const_func __attribute__((overloadable)) half_divide(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) half_divide(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) half_divide(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) half_divide(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) half_divide(float16 x, float16 y);
/**
* Compute the base- e exponential of x.
*/
float const_func __attribute__((overloadable)) half_exp(float x);
float2 const_func __attribute__((overloadable)) half_exp(float2 x);
float3 const_func __attribute__((overloadable)) half_exp(float3 x);
float4 const_func __attribute__((overloadable)) half_exp(float4 x);
float8 const_func __attribute__((overloadable)) half_exp(float8 x);
float16 const_func __attribute__((overloadable)) half_exp(float16 x);
/**
* Compute the base- 2 exponential of x.
*/
float const_func __attribute__((overloadable)) half_exp2(float x);
float2 const_func __attribute__((overloadable)) half_exp2(float2 x);
float3 const_func __attribute__((overloadable)) half_exp2(float3 x);
float4 const_func __attribute__((overloadable)) half_exp2(float4 x);
float8 const_func __attribute__((overloadable)) half_exp2(float8 x);
float16 const_func __attribute__((overloadable)) half_exp2(float16 x);
/**
* Compute the base- 10 exponential of x.
*/
float const_func __attribute__((overloadable)) half_exp10(float x);
float2 const_func __attribute__((overloadable)) half_exp10(float2 x);
float3 const_func __attribute__((overloadable)) half_exp10(float3 x);
float4 const_func __attribute__((overloadable)) half_exp10(float4 x);
float8 const_func __attribute__((overloadable)) half_exp10(float8 x);
float16 const_func __attribute__((overloadable)) half_exp10(float16 x);
/**
* Compute natural logarithm.
*/
float const_func __attribute__((overloadable)) half_log(float x);
float2 const_func __attribute__((overloadable)) half_log(float2 x);
float3 const_func __attribute__((overloadable)) half_log(float3 x);
float4 const_func __attribute__((overloadable)) half_log(float4 x);
float8 const_func __attribute__((overloadable)) half_log(float8 x);
float16 const_func __attribute__((overloadable)) half_log(float16 x);
/**
* Compute a base 2 logarithm.
*/
float const_func __attribute__((overloadable)) half_log2(float x);
float2 const_func __attribute__((overloadable)) half_log2(float2 x);
float3 const_func __attribute__((overloadable)) half_log2(float3 x);
float4 const_func __attribute__((overloadable)) half_log2(float4 x);
float8 const_func __attribute__((overloadable)) half_log2(float8 x);
float16 const_func __attribute__((overloadable)) half_log2(float16 x);
/**
* Compute a base 10 logarithm.
*/
float const_func __attribute__((overloadable)) half_log10(float x);
float2 const_func __attribute__((overloadable)) half_log10(float2 x);
float3 const_func __attribute__((overloadable)) half_log10(float3 x);
float4 const_func __attribute__((overloadable)) half_log10(float4 x);
float8 const_func __attribute__((overloadable)) half_log10(float8 x);
float16 const_func __attribute__((overloadable)) half_log10(float16 x);
/**
* Compute x to the power y, where x is >= 0.
*/
float const_func __attribute__((overloadable)) half_powr(float x, float y);
float2 const_func __attribute__((overloadable)) half_powr(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) half_powr(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) half_powr(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) half_powr(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) half_powr(float16 x, float16 y);
/**
* Compute reciprocal.
*/
float const_func __attribute__((overloadable)) half_recip(float x);
float2 const_func __attribute__((overloadable)) half_recip(float2 x);
float3 const_func __attribute__((overloadable)) half_recip(float3 x);
float4 const_func __attribute__((overloadable)) half_recip(float4 x);
float8 const_func __attribute__((overloadable)) half_recip(float8 x);
float16 const_func __attribute__((overloadable)) half_recip(float16 x);
/**
* Compute inverse square root.
*/
float const_func __attribute__((overloadable)) half_rsqrt(float x);
float2 const_func __attribute__((overloadable)) half_rsqrt(float2 x);
float3 const_func __attribute__((overloadable)) half_rsqrt(float3 x);
float4 const_func __attribute__((overloadable)) half_rsqrt(float4 x);
float8 const_func __attribute__((overloadable)) half_rsqrt(float8 x);
float16 const_func __attribute__((overloadable)) half_rsqrt(float16 x);
/**
* Compute sine. x must be in the range -2^16 … +2^16.
*/
float const_func __attribute__((overloadable)) half_sin(float x);
float2 const_func __attribute__((overloadable)) half_sin(float2 x);
float3 const_func __attribute__((overloadable)) half_sin(float3 x);
float4 const_func __attribute__((overloadable)) half_sin(float4 x);
float8 const_func __attribute__((overloadable)) half_sin(float8 x);
float16 const_func __attribute__((overloadable)) half_sin(float16 x);
/**
* Compute square root.
*/
float const_func __attribute__((overloadable)) half_sqrt(float x);
float2 const_func __attribute__((overloadable)) half_sqrt(float2 x);
float3 const_func __attribute__((overloadable)) half_sqrt(float3 x);
float4 const_func __attribute__((overloadable)) half_sqrt(float4 x);
float8 const_func __attribute__((overloadable)) half_sqrt(float8 x);
float16 const_func __attribute__((overloadable)) half_sqrt(float16 x);
/**
* Compute tangent. x must be in the range -216 … +216.
*/
float const_func __attribute__((overloadable)) half_tan(float x);
float2 const_func __attribute__((overloadable)) half_tan(float2 x);
float3 const_func __attribute__((overloadable)) half_tan(float3 x);
float4 const_func __attribute__((overloadable)) half_tan(float4 x);
float8 const_func __attribute__((overloadable)) half_tan(float8 x);
float16 const_func __attribute__((overloadable)) half_tan(float16 x);
/**
* Compute cosine over an implementation-defined range.
* The maximum error is implementation-defined.
*/
float const_func __attribute__((overloadable)) native_cos(float x);
float2 const_func __attribute__((overloadable)) native_cos(float2 x);
float3 const_func __attribute__((overloadable)) native_cos(float3 x);
float4 const_func __attribute__((overloadable)) native_cos(float4 x);
float8 const_func __attribute__((overloadable)) native_cos(float8 x);
float16 const_func __attribute__((overloadable)) native_cos(float16 x);
// EXTENSION: native double
double const_func __attribute__((overloadable)) native_cos(double x);
double2 const_func __attribute__((overloadable)) native_cos(double2 x);
double3 const_func __attribute__((overloadable)) native_cos(double3 x);
double4 const_func __attribute__((overloadable)) native_cos(double4 x);
double8 const_func __attribute__((overloadable)) native_cos(double8 x);
double16 const_func __attribute__((overloadable)) native_cos(double16 x);
/**
* Compute x / y over an implementation-defined range.
* The maximum error is implementation-defined.
*/
float const_func __attribute__((overloadable)) native_divide(float x, float y);
float2 const_func __attribute__((overloadable)) native_divide(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) native_divide(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) native_divide(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) native_divide(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) native_divide(float16 x, float16 y);
// EXTENSION: native double
double const_func __attribute__((overloadable)) native_divide(double x, double y);
double2 const_func __attribute__((overloadable)) native_divide(double2 x, double2 y);
double3 const_func __attribute__((overloadable)) native_divide(double3 x, double3 y);
double4 const_func __attribute__((overloadable)) native_divide(double4 x, double4 y);
double8 const_func __attribute__((overloadable)) native_divide(double8 x, double8 y);
double16 const_func __attribute__((overloadable)) native_divide(double16 x, double16 y);
/**
* Compute the base- e exponential of x over an
* implementation-defined range. The maximum error is
* implementation-defined.
*/
float const_func __attribute__((overloadable)) native_exp(float x);
float2 const_func __attribute__((overloadable)) native_exp(float2 x);
float3 const_func __attribute__((overloadable)) native_exp(float3 x);
float4 const_func __attribute__((overloadable)) native_exp(float4 x);
float8 const_func __attribute__((overloadable)) native_exp(float8 x);
float16 const_func __attribute__((overloadable)) native_exp(float16 x);
/**
* Compute the base- 2 exponential of x over an
* implementation-defined range. The maximum error is
* implementation-defined.
*/
float const_func __attribute__((overloadable)) native_exp2(float x);
float2 const_func __attribute__((overloadable)) native_exp2(float2 x);
float3 const_func __attribute__((overloadable)) native_exp2(float3 x);
float4 const_func __attribute__((overloadable)) native_exp2(float4 x);
float8 const_func __attribute__((overloadable)) native_exp2(float8 x);
float16 const_func __attribute__((overloadable)) native_exp2(float16 x);
/**
* Compute the base- 10 exponential of x over an
* implementation-defined range. The maximum error is
* implementation-defined.
*/
float const_func __attribute__((overloadable)) native_exp10(float x);
float2 const_func __attribute__((overloadable)) native_exp10(float2 x);
float3 const_func __attribute__((overloadable)) native_exp10(float3 x);
float4 const_func __attribute__((overloadable)) native_exp10(float4 x);
float8 const_func __attribute__((overloadable)) native_exp10(float8 x);
float16 const_func __attribute__((overloadable)) native_exp10(float16 x);
/**
* Compute natural logarithm over an implementationdefined
* range. The maximum error is implementation
* defined.
*/
float const_func __attribute__((overloadable)) native_log(float x);
float2 const_func __attribute__((overloadable)) native_log(float2 x);
float3 const_func __attribute__((overloadable)) native_log(float3 x);
float4 const_func __attribute__((overloadable)) native_log(float4 x);
float8 const_func __attribute__((overloadable)) native_log(float8 x);
float16 const_func __attribute__((overloadable)) native_log(float16 x);
/**
* Compute a base 2 logarithm over an implementationdefined
* range. The maximum error is implementationdefined.
*/
float const_func __attribute__((overloadable)) native_log2(float x);
float2 const_func __attribute__((overloadable)) native_log2(float2 x);
float3 const_func __attribute__((overloadable)) native_log2(float3 x);
float4 const_func __attribute__((overloadable)) native_log2(float4 x);
float8 const_func __attribute__((overloadable)) native_log2(float8 x);
float16 const_func __attribute__((overloadable)) native_log2(float16 x);
/**
* Compute a base 10 logarithm over an implementationdefined
* range. The maximum error is implementationdefined.
*/
float const_func __attribute__((overloadable)) native_log10(float x);
float2 const_func __attribute__((overloadable)) native_log10(float2 x);
float3 const_func __attribute__((overloadable)) native_log10(float3 x);
float4 const_func __attribute__((overloadable)) native_log10(float4 x);
float8 const_func __attribute__((overloadable)) native_log10(float8 x);
float16 const_func __attribute__((overloadable)) native_log10(float16 x);
/**
* Compute x to the power y, where x is >= 0. The range of
* x and y are implementation-defined. The maximum error
* is implementation-defined.
*/
float const_func __attribute__((overloadable)) native_powr(float x, float y);
float2 const_func __attribute__((overloadable)) native_powr(float2 x, float2 y);
float3 const_func __attribute__((overloadable)) native_powr(float3 x, float3 y);
float4 const_func __attribute__((overloadable)) native_powr(float4 x, float4 y);
float8 const_func __attribute__((overloadable)) native_powr(float8 x, float8 y);
float16 const_func __attribute__((overloadable)) native_powr(float16 x, float16 y);
/**
* Compute reciprocal over an implementation-defined
* range. The maximum error is implementation-defined.
*/
float const_func __attribute__((overloadable)) native_recip(float x);
float2 const_func __attribute__((overloadable)) native_recip(float2 x);
float3 const_func __attribute__((overloadable)) native_recip(float3 x);
float4 const_func __attribute__((overloadable)) native_recip(float4 x);
float8 const_func __attribute__((overloadable)) native_recip(float8 x);
float16 const_func __attribute__((overloadable)) native_recip(float16 x);
/**
* Compute inverse square root over an implementationdefined
* range. The maximum error is implementationdefined.
*/
float const_func __attribute__((overloadable)) native_rsqrt(float x);
float2 const_func __attribute__((overloadable)) native_rsqrt(float2 x);
float3 const_func __attribute__((overloadable)) native_rsqrt(float3 x);
float4 const_func __attribute__((overloadable)) native_rsqrt(float4 x);
float8 const_func __attribute__((overloadable)) native_rsqrt(float8 x);
float16 const_func __attribute__((overloadable)) native_rsqrt(float16 x);
/**
* Compute sine over an implementation-defined range.
* The maximum error is implementation-defined.
*/
float const_func __attribute__((overloadable)) native_sin(float x);
float2 const_func __attribute__((overloadable)) native_sin(float2 x);
float3 const_func __attribute__((overloadable)) native_sin(float3 x);
float4 const_func __attribute__((overloadable)) native_sin(float4 x);
float8 const_func __attribute__((overloadable)) native_sin(float8 x);
float16 const_func __attribute__((overloadable)) native_sin(float16 x);
/**
* Compute square root over an implementation-defined
* range. The maximum error is implementation-defined.
*/
float const_func __attribute__((overloadable)) native_sqrt(float x);
float2 const_func __attribute__((overloadable)) native_sqrt(float2 x);
float3 const_func __attribute__((overloadable)) native_sqrt(float3 x);
float4 const_func __attribute__((overloadable)) native_sqrt(float4 x);
float8 const_func __attribute__((overloadable)) native_sqrt(float8 x);
float16 const_func __attribute__((overloadable)) native_sqrt(float16 x);
/**
* Compute tangent over an implementation-defined range.
* The maximum error is implementation-defined.
*/
float const_func __attribute__((overloadable)) native_tan(float x);
float2 const_func __attribute__((overloadable)) native_tan(float2 x);
float3 const_func __attribute__((overloadable)) native_tan(float3 x);
float4 const_func __attribute__((overloadable)) native_tan(float4 x);
float8 const_func __attribute__((overloadable)) native_tan(float8 x);
float16 const_func __attribute__((overloadable)) native_tan(float16 x);
// Integer functions:
/**
* Returns | x |.
*/
uchar const_func __attribute__((overloadable)) abs(char x);
uchar const_func __attribute__((overloadable)) abs(uchar x);
uchar2 const_func __attribute__((overloadable)) abs(char2 x);
uchar2 const_func __attribute__((overloadable)) abs(uchar2 x);
uchar3 const_func __attribute__((overloadable)) abs(char3 x);
uchar3 const_func __attribute__((overloadable)) abs(uchar3 x);
uchar4 const_func __attribute__((overloadable)) abs(char4 x);
uchar4 const_func __attribute__((overloadable)) abs(uchar4 x);
uchar8 const_func __attribute__((overloadable)) abs(char8 x);
uchar8 const_func __attribute__((overloadable)) abs(uchar8 x);
uchar16 const_func __attribute__((overloadable)) abs(char16 x);
uchar16 const_func __attribute__((overloadable)) abs(uchar16 x);
ushort const_func __attribute__((overloadable)) abs(short x);
ushort const_func __attribute__((overloadable)) abs(ushort x);
ushort2 const_func __attribute__((overloadable)) abs(short2 x);
ushort2 const_func __attribute__((overloadable)) abs(ushort2 x);
ushort3 const_func __attribute__((overloadable)) abs(short3 x);
ushort3 const_func __attribute__((overloadable)) abs(ushort3 x);
ushort4 const_func __attribute__((overloadable)) abs(short4 x);
ushort4 const_func __attribute__((overloadable)) abs(ushort4 x);
ushort8 const_func __attribute__((overloadable)) abs(short8 x);
ushort8 const_func __attribute__((overloadable)) abs(ushort8 x);
ushort16 const_func __attribute__((overloadable)) abs(short16 x);
ushort16 const_func __attribute__((overloadable)) abs(ushort16 x);
uint const_func __attribute__((overloadable)) abs(int x);
uint const_func __attribute__((overloadable)) abs(uint x);
uint2 const_func __attribute__((overloadable)) abs(int2 x);
uint2 const_func __attribute__((overloadable)) abs(uint2 x);
uint3 const_func __attribute__((overloadable)) abs(int3 x);
uint3 const_func __attribute__((overloadable)) abs(uint3 x);
uint4 const_func __attribute__((overloadable)) abs(int4 x);
uint4 const_func __attribute__((overloadable)) abs(uint4 x);
uint8 const_func __attribute__((overloadable)) abs(int8 x);
uint8 const_func __attribute__((overloadable)) abs(uint8 x);
uint16 const_func __attribute__((overloadable)) abs(int16 x);
uint16 const_func __attribute__((overloadable)) abs(uint16 x);
ulong const_func __attribute__((overloadable)) abs(long x);
ulong const_func __attribute__((overloadable)) abs(ulong x);
ulong2 const_func __attribute__((overloadable)) abs(long2 x);
ulong2 const_func __attribute__((overloadable)) abs(ulong2 x);
ulong3 const_func __attribute__((overloadable)) abs(long3 x);
ulong3 const_func __attribute__((overloadable)) abs(ulong3 x);
ulong4 const_func __attribute__((overloadable)) abs(long4 x);
ulong4 const_func __attribute__((overloadable)) abs(ulong4 x);
ulong8 const_func __attribute__((overloadable)) abs(long8 x);
ulong8 const_func __attribute__((overloadable)) abs(ulong8 x);
ulong16 const_func __attribute__((overloadable)) abs(long16 x);
ulong16 const_func __attribute__((overloadable)) abs(ulong16 x);
/**
* Returns | x – y | without modulo overflow.
*/
uchar const_func __attribute__((overloadable)) abs_diff(char x, char y);
uchar const_func __attribute__((overloadable)) abs_diff(uchar x, uchar y);
uchar2 const_func __attribute__((overloadable)) abs_diff(char2 x, char2 y);
uchar2 const_func __attribute__((overloadable)) abs_diff(uchar2 x, uchar2 y);
uchar3 const_func __attribute__((overloadable)) abs_diff(char3 x, char3 y);
uchar3 const_func __attribute__((overloadable)) abs_diff(uchar3 x, uchar3 y);
uchar4 const_func __attribute__((overloadable)) abs_diff(char4 x, char4 y);
uchar4 const_func __attribute__((overloadable)) abs_diff(uchar4 x, uchar4 y);
uchar8 const_func __attribute__((overloadable)) abs_diff(char8 x, char8 y);
uchar8 const_func __attribute__((overloadable)) abs_diff(uchar8 x, uchar8 y);
uchar16 const_func __attribute__((overloadable)) abs_diff(char16 x, char16 y);
uchar16 const_func __attribute__((overloadable)) abs_diff(uchar16 x, uchar16 y);
ushort const_func __attribute__((overloadable)) abs_diff(short x, short y);
ushort const_func __attribute__((overloadable)) abs_diff(ushort x, ushort y);
ushort2 const_func __attribute__((overloadable)) abs_diff(short2 x, short2 y);
ushort2 const_func __attribute__((overloadable)) abs_diff(ushort2 x, ushort2 y);
ushort3 const_func __attribute__((overloadable)) abs_diff(short3 x, short3 y);
ushort3 const_func __attribute__((overloadable)) abs_diff(ushort3 x, ushort3 y);
ushort4 const_func __attribute__((overloadable)) abs_diff(short4 x, short4 y);
ushort4 const_func __attribute__((overloadable)) abs_diff(ushort4 x, ushort4 y);
ushort8 const_func __attribute__((overloadable)) abs_diff(short8 x, short8 y);
ushort8 const_func __attribute__((overloadable)) abs_diff(ushort8 x, ushort8 y);
ushort16 const_func __attribute__((overloadable)) abs_diff(short16 x, short16 y);
ushort16 const_func __attribute__((overloadable)) abs_diff(ushort16 x, ushort16 y);
uint const_func __attribute__((overloadable)) abs_diff(int x, int y);
uint const_func __attribute__((overloadable)) abs_diff(uint x, uint y);
uint2 const_func __attribute__((overloadable)) abs_diff(int2 x, int2 y);
uint2 const_func __attribute__((overloadable)) abs_diff(uint2 x, uint2 y);
uint3 const_func __attribute__((overloadable)) abs_diff(int3 x, int3 y);
uint3 const_func __attribute__((overloadable)) abs_diff(uint3 x, uint3 y);
uint4 const_func __attribute__((overloadable)) abs_diff(int4 x, int4 y);
uint4 const_func __attribute__((overloadable)) abs_diff(uint4 x, uint4 y);
uint8 const_func __attribute__((overloadable)) abs_diff(int8 x, int8 y);
uint8 const_func __attribute__((overloadable)) abs_diff(uint8 x, uint8 y);
uint16 const_func __attribute__((overloadable)) abs_diff(int16 x, int16 y);
uint16 const_func __attribute__((overloadable)) abs_diff(uint16 x, uint16 y);
ulong const_func __attribute__((overloadable)) abs_diff(long x, long y);
ulong const_func __attribute__((overloadable)) abs_diff(ulong x, ulong y);
ulong2 const_func __attribute__((overloadable)) abs_diff(long2 x, long2 y);
ulong2 const_func __attribute__((overloadable)) abs_diff(ulong2 x, ulong2 y);
ulong3 const_func __attribute__((overloadable)) abs_diff(long3 x, long3 y);
ulong3 const_func __attribute__((overloadable)) abs_diff(ulong3 x, ulong3 y);
ulong4 const_func __attribute__((overloadable)) abs_diff(long4 x, long4 y);
ulong4 const_func __attribute__((overloadable)) abs_diff(ulong4 x, ulong4 y);
ulong8 const_func __attribute__((overloadable)) abs_diff(long8 x, long8 y);
ulong8 const_func __attribute__((overloadable)) abs_diff(ulong8 x, ulong8 y);
ulong16 const_func __attribute__((overloadable)) abs_diff(long16 x, long16 y);
ulong16 const_func __attribute__((overloadable)) abs_diff(ulong16 x, ulong16 y);
/**
* Returns x + y and saturates the result.
*/
char const_func __attribute__((overloadable)) add_sat(char x, char y);
uchar const_func __attribute__((overloadable)) add_sat(uchar x, uchar y);
char2 const_func __attribute__((overloadable)) add_sat(char2 x, char2 y);
uchar2 const_func __attribute__((overloadable)) add_sat(uchar2 x, uchar2 y);
char3 const_func __attribute__((overloadable)) add_sat(char3 x, char3 y);
uchar3 const_func __attribute__((overloadable)) add_sat(uchar3 x, uchar3 y);
char4 const_func __attribute__((overloadable)) add_sat(char4 x, char4 y);
uchar4 const_func __attribute__((overloadable)) add_sat(uchar4 x, uchar4 y);
char8 const_func __attribute__((overloadable)) add_sat(char8 x, char8 y);
uchar8 const_func __attribute__((overloadable)) add_sat(uchar8 x, uchar8 y);
char16 const_func __attribute__((overloadable)) add_sat(char16 x, char16 y);
uchar16 const_func __attribute__((overloadable)) add_sat(uchar16 x, uchar16 y);
short const_func __attribute__((overloadable)) add_sat(short x, short y);
ushort const_func __attribute__((overloadable)) add_sat(ushort x, ushort y);
short2 const_func __attribute__((overloadable)) add_sat(short2 x, short2 y);
ushort2 const_func __attribute__((overloadable)) add_sat(ushort2 x, ushort2 y);
short3 const_func __attribute__((overloadable)) add_sat(short3 x, short3 y);
ushort3 const_func __attribute__((overloadable)) add_sat(ushort3 x, ushort3 y);
short4 const_func __attribute__((overloadable)) add_sat(short4 x, short4 y);
ushort4 const_func __attribute__((overloadable)) add_sat(ushort4 x, ushort4 y);
short8 const_func __attribute__((overloadable)) add_sat(short8 x, short8 y);
ushort8 const_func __attribute__((overloadable)) add_sat(ushort8 x, ushort8 y);
short16 const_func __attribute__((overloadable)) add_sat(short16 x, short16 y);
ushort16 const_func __attribute__((overloadable)) add_sat(ushort16 x, ushort16 y);
int const_func __attribute__((overloadable)) add_sat(int x, int y);
uint const_func __attribute__((overloadable)) add_sat(uint x, uint y);
int2 const_func __attribute__((overloadable)) add_sat(int2 x, int2 y);
uint2 const_func __attribute__((overloadable)) add_sat(uint2 x, uint2 y);
int3 const_func __attribute__((overloadable)) add_sat(int3 x, int3 y);
uint3 const_func __attribute__((overloadable)) add_sat(uint3 x, uint3 y);
int4 const_func __attribute__((overloadable)) add_sat(int4 x, int4 y);
uint4 const_func __attribute__((overloadable)) add_sat(uint4 x, uint4 y);
int8 const_func __attribute__((overloadable)) add_sat(int8 x, int8 y);
uint8 const_func __attribute__((overloadable)) add_sat(uint8 x, uint8 y);
int16 const_func __attribute__((overloadable)) add_sat(int16 x, int16 y);
uint16 const_func __attribute__((overloadable)) add_sat(uint16 x, uint16 y);
long const_func __attribute__((overloadable)) add_sat(long x, long y);
ulong const_func __attribute__((overloadable)) add_sat(ulong x, ulong y);
long2 const_func __attribute__((overloadable)) add_sat(long2 x, long2 y);
ulong2 const_func __attribute__((overloadable)) add_sat(ulong2 x, ulong2 y);
long3 const_func __attribute__((overloadable)) add_sat(long3 x, long3 y);
ulong3 const_func __attribute__((overloadable)) add_sat(ulong3 x, ulong3 y);
long4 const_func __attribute__((overloadable)) add_sat(long4 x, long4 y);
ulong4 const_func __attribute__((overloadable)) add_sat(ulong4 x, ulong4 y);
long8 const_func __attribute__((overloadable)) add_sat(long8 x, long8 y);
ulong8 const_func __attribute__((overloadable)) add_sat(ulong8 x, ulong8 y);
long16 const_func __attribute__((overloadable)) add_sat(long16 x, long16 y);
ulong16 const_func __attribute__((overloadable)) add_sat(ulong16 x, ulong16 y);
/**
* Returns (x + y) >> 1. The intermediate sum does
* not modulo overflow.
*/
char const_func __attribute__((overloadable)) hadd(char x, char y);
uchar const_func __attribute__((overloadable)) hadd(uchar x, uchar y);
char2 const_func __attribute__((overloadable)) hadd(char2 x, char2 y);
uchar2 const_func __attribute__((overloadable)) hadd(uchar2 x, uchar2 y);
char3 const_func __attribute__((overloadable)) hadd(char3 x, char3 y);
uchar3 const_func __attribute__((overloadable)) hadd(uchar3 x, uchar3 y);
char4 const_func __attribute__((overloadable)) hadd(char4 x, char4 y);
uchar4 const_func __attribute__((overloadable)) hadd(uchar4 x, uchar4 y);
char8 const_func __attribute__((overloadable)) hadd(char8 x, char8 y);
uchar8 const_func __attribute__((overloadable)) hadd(uchar8 x, uchar8 y);
char16 const_func __attribute__((overloadable)) hadd(char16 x, char16 y);
uchar16 const_func __attribute__((overloadable)) hadd(uchar16 x, uchar16 y);
short const_func __attribute__((overloadable)) hadd(short x, short y);
ushort const_func __attribute__((overloadable)) hadd(ushort x, ushort y);
short2 const_func __attribute__((overloadable)) hadd(short2 x, short2 y);
ushort2 const_func __attribute__((overloadable)) hadd(ushort2 x, ushort2 y);
short3 const_func __attribute__((overloadable)) hadd(short3 x, short3 y);
ushort3 const_func __attribute__((overloadable)) hadd(ushort3 x, ushort3 y);
short4 const_func __attribute__((overloadable)) hadd(short4 x, short4 y);
ushort4 const_func __attribute__((overloadable)) hadd(ushort4 x, ushort4 y);
short8 const_func __attribute__((overloadable)) hadd(short8 x, short8 y);
ushort8 const_func __attribute__((overloadable)) hadd(ushort8 x, ushort8 y);
short16 const_func __attribute__((overloadable)) hadd(short16 x, short16 y);
ushort16 const_func __attribute__((overloadable)) hadd(ushort16 x, ushort16 y);
int const_func __attribute__((overloadable)) hadd(int x, int y);
uint const_func __attribute__((overloadable)) hadd(uint x, uint y);
int2 const_func __attribute__((overloadable)) hadd(int2 x, int2 y);
uint2 const_func __attribute__((overloadable)) hadd(uint2 x, uint2 y);
int3 const_func __attribute__((overloadable)) hadd(int3 x, int3 y);
uint3 const_func __attribute__((overloadable)) hadd(uint3 x, uint3 y);
int4 const_func __attribute__((overloadable)) hadd(int4 x, int4 y);
uint4 const_func __attribute__((overloadable)) hadd(uint4 x, uint4 y);
int8 const_func __attribute__((overloadable)) hadd(int8 x, int8 y);
uint8 const_func __attribute__((overloadable)) hadd(uint8 x, uint8 y);
int16 const_func __attribute__((overloadable)) hadd(int16 x, int16 y);
uint16 const_func __attribute__((overloadable)) hadd(uint16 x, uint16 y);
long const_func __attribute__((overloadable)) hadd(long x, long y);
ulong const_func __attribute__((overloadable)) hadd(ulong x, ulong y);
long2 const_func __attribute__((overloadable)) hadd(long2 x, long2 y);
ulong2 const_func __attribute__((overloadable)) hadd(ulong2 x, ulong2 y);
long3 const_func __attribute__((overloadable)) hadd(long3 x, long3 y);
ulong3 const_func __attribute__((overloadable)) hadd(ulong3 x, ulong3 y);
long4 const_func __attribute__((overloadable)) hadd(long4 x, long4 y);
ulong4 const_func __attribute__((overloadable)) hadd(ulong4 x, ulong4 y);
long8 const_func __attribute__((overloadable)) hadd(long8 x, long8 y);
ulong8 const_func __attribute__((overloadable)) hadd(ulong8 x, ulong8 y);
long16 const_func __attribute__((overloadable)) hadd(long16 x, long16 y);
ulong16 const_func __attribute__((overloadable)) hadd(ulong16 x, ulong16 y);
/**
* Returns (x + y + 1) >> 1. The intermediate sum
* does not modulo overflow.
*/
char const_func __attribute__((overloadable)) rhadd(char x, char y);
uchar const_func __attribute__((overloadable)) rhadd(uchar x, uchar y);
char2 const_func __attribute__((overloadable)) rhadd(char2 x, char2 y);
uchar2 const_func __attribute__((overloadable)) rhadd(uchar2 x, uchar2 y);
char3 const_func __attribute__((overloadable)) rhadd(char3 x, char3 y);
uchar3 const_func __attribute__((overloadable)) rhadd(uchar3 x, uchar3 y);
char4 const_func __attribute__((overloadable)) rhadd(char4 x, char4 y);
uchar4 const_func __attribute__((overloadable)) rhadd(uchar4 x, uchar4 y);
char8 const_func __attribute__((overloadable)) rhadd(char8 x, char8 y);
uchar8 const_func __attribute__((overloadable)) rhadd(uchar8 x, uchar8 y);
char16 const_func __attribute__((overloadable)) rhadd(char16 x, char16 y);
uchar16 const_func __attribute__((overloadable)) rhadd(uchar16 x, uchar16 y);
short const_func __attribute__((overloadable)) rhadd(short x, short y);
ushort const_func __attribute__((overloadable)) rhadd(ushort x, ushort y);
short2 const_func __attribute__((overloadable)) rhadd(short2 x, short2 y);
ushort2 const_func __attribute__((overloadable)) rhadd(ushort2 x, ushort2 y);
short3 const_func __attribute__((overloadable)) rhadd(short3 x, short3 y);
ushort3 const_func __attribute__((overloadable)) rhadd(ushort3 x, ushort3 y);
short4 const_func __attribute__((overloadable)) rhadd(short4 x, short4 y);
ushort4 const_func __attribute__((overloadable)) rhadd(ushort4 x, ushort4 y);
short8 const_func __attribute__((overloadable)) rhadd(short8 x, short8 y);
ushort8 const_func __attribute__((overloadable)) rhadd(ushort8 x, ushort8 y);
short16 const_func __attribute__((overloadable)) rhadd(short16 x, short16 y);
ushort16 const_func __attribute__((overloadable)) rhadd(ushort16 x, ushort16 y);
int const_func __attribute__((overloadable)) rhadd(int x, int y);
uint const_func __attribute__((overloadable)) rhadd(uint x, uint y);
int2 const_func __attribute__((overloadable)) rhadd(int2 x, int2 y);
uint2 const_func __attribute__((overloadable)) rhadd(uint2 x, uint2 y);
int3 const_func __attribute__((overloadable)) rhadd(int3 x, int3 y);
uint3 const_func __attribute__((overloadable)) rhadd(uint3 x, uint3 y);
int4 const_func __attribute__((overloadable)) rhadd(int4 x, int4 y);
uint4 const_func __attribute__((overloadable)) rhadd(uint4 x, uint4 y);
int8 const_func __attribute__((overloadable)) rhadd(int8 x, int8 y);
uint8 const_func __attribute__((overloadable)) rhadd(uint8 x, uint8 y);
int16 const_func __attribute__((overloadable)) rhadd(int16 x, int16 y);
uint16 const_func __attribute__((overloadable)) rhadd(uint16 x, uint16 y);
long const_func __attribute__((overloadable)) rhadd(long x, long y);
ulong const_func __attribute__((overloadable)) rhadd(ulong x, ulong y);
long2 const_func __attribute__((overloadable)) rhadd(long2 x, long2 y);
ulong2 const_func __attribute__((overloadable)) rhadd(ulong2 x, ulong2 y);
long3 const_func __attribute__((overloadable)) rhadd(long3 x, long3 y);
ulong3 const_func __attribute__((overloadable)) rhadd(ulong3 x, ulong3 y);
long4 const_func __attribute__((overloadable)) rhadd(long4 x, long4 y);
ulong4 const_func __attribute__((overloadable)) rhadd(ulong4 x, ulong4 y);
long8 const_func __attribute__((overloadable)) rhadd(long8 x, long8 y);
ulong8 const_func __attribute__((overloadable)) rhadd(ulong8 x, ulong8 y);
long16 const_func __attribute__((overloadable)) rhadd(long16 x, long16 y);
ulong16 const_func __attribute__((overloadable)) rhadd(ulong16 x, ulong16 y);
/**
* Returns min(max(x, minval), maxval).
* Results are undefined if minval > maxval.
*/
char const_func __attribute__((overloadable)) clamp(char x, char minval, char maxval);
uchar const_func __attribute__((overloadable)) clamp(uchar x, uchar minval, uchar maxval);
char2 const_func __attribute__((overloadable)) clamp(char2 x, char2 minval, char2 maxval);
uchar2 const_func __attribute__((overloadable)) clamp(uchar2 x, uchar2 minval, uchar2 maxval);
char3 const_func __attribute__((overloadable)) clamp(char3 x, char3 minval, char3 maxval);
uchar3 const_func __attribute__((overloadable)) clamp(uchar3 x, uchar3 minval, uchar3 maxval);
char4 const_func __attribute__((overloadable)) clamp(char4 x, char4 minval, char4 maxval);
uchar4 const_func __attribute__((overloadable)) clamp(uchar4 x, uchar4 minval, uchar4 maxval);
char8 const_func __attribute__((overloadable)) clamp(char8 x, char8 minval, char8 maxval);
uchar8 const_func __attribute__((overloadable)) clamp(uchar8 x, uchar8 minval, uchar8 maxval);
char16 const_func __attribute__((overloadable)) clamp(char16 x, char16 minval, char16 maxval);
uchar16 const_func __attribute__((overloadable)) clamp(uchar16 x, uchar16 minval, uchar16 maxval);
short const_func __attribute__((overloadable)) clamp(short x, short minval, short maxval);
ushort const_func __attribute__((overloadable)) clamp(ushort x, ushort minval, ushort maxval);
short2 const_func __attribute__((overloadable)) clamp(short2 x, short2 minval, short2 maxval);
ushort2 const_func __attribute__((overloadable)) clamp(ushort2 x, ushort2 minval, ushort2 maxval);
short3 const_func __attribute__((overloadable)) clamp(short3 x, short3 minval, short3 maxval);
ushort3 const_func __attribute__((overloadable)) clamp(ushort3 x, ushort3 minval, ushort3 maxval);
short4 const_func __attribute__((overloadable)) clamp(short4 x, short4 minval, short4 maxval);
ushort4 const_func __attribute__((overloadable)) clamp(ushort4 x, ushort4 minval, ushort4 maxval);
short8 const_func __attribute__((overloadable)) clamp(short8 x, short8 minval, short8 maxval);
ushort8 const_func __attribute__((overloadable)) clamp(ushort8 x, ushort8 minval, ushort8 maxval);
short16 const_func __attribute__((overloadable)) clamp(short16 x, short16 minval, short16 maxval);
ushort16 const_func __attribute__((overloadable)) clamp(ushort16 x, ushort16 minval, ushort16 maxval);
int const_func __attribute__((overloadable)) clamp(int x, int minval, int maxval);
uint const_func __attribute__((overloadable)) clamp(uint x, uint minval, uint maxval);
int2 const_func __attribute__((overloadable)) clamp(int2 x, int2 minval, int2 maxval);
uint2 const_func __attribute__((overloadable)) clamp(uint2 x, uint2 minval, uint2 maxval);
int3 const_func __attribute__((overloadable)) clamp(int3 x, int3 minval, int3 maxval);
uint3 const_func __attribute__((overloadable)) clamp(uint3 x, uint3 minval, uint3 maxval);
int4 const_func __attribute__((overloadable)) clamp(int4 x, int4 minval, int4 maxval);
uint4 const_func __attribute__((overloadable)) clamp(uint4 x, uint4 minval, uint4 maxval);
int8 const_func __attribute__((overloadable)) clamp(int8 x, int8 minval, int8 maxval);
uint8 const_func __attribute__((overloadable)) clamp(uint8 x, uint8 minval, uint8 maxval);
int16 const_func __attribute__((overloadable)) clamp(int16 x, int16 minval, int16 maxval);
uint16 const_func __attribute__((overloadable)) clamp(uint16 x, uint16 minval, uint16 maxval);
long const_func __attribute__((overloadable)) clamp(long x, long minval, long maxval);
ulong const_func __attribute__((overloadable)) clamp(ulong x, ulong minval, ulong maxval);
long2 const_func __attribute__((overloadable)) clamp(long2 x, long2 minval, long2 maxval);
ulong2 const_func __attribute__((overloadable)) clamp(ulong2 x, ulong2 minval, ulong2 maxval);
long3 const_func __attribute__((overloadable)) clamp(long3 x, long3 minval, long3 maxval);
ulong3 const_func __attribute__((overloadable)) clamp(ulong3 x, ulong3 minval, ulong3 maxval);
long4 const_func __attribute__((overloadable)) clamp(long4 x, long4 minval, long4 maxval);
ulong4 const_func __attribute__((overloadable)) clamp(ulong4 x, ulong4 minval, ulong4 maxval);
long8 const_func __attribute__((overloadable)) clamp(long8 x, long8 minval, long8 maxval);
ulong8 const_func __attribute__((overloadable)) clamp(ulong8 x, ulong8 minval, ulong8 maxval);
long16 const_func __attribute__((overloadable)) clamp(long16 x, long16 minval, long16 maxval);
ulong16 const_func __attribute__((overloadable)) clamp(ulong16 x, ulong16 minval, ulong16 maxval);
char const_func __attribute__((overloadable)) clamp(char x, char minval, char maxval);
uchar const_func __attribute__((overloadable)) clamp(uchar x, uchar minval, uchar maxval);
char2 const_func __attribute__((overloadable)) clamp(char2 x, char minval, char maxval);
uchar2 const_func __attribute__((overloadable)) clamp(uchar2 x, uchar minval, uchar maxval);
char3 const_func __attribute__((overloadable)) clamp(char3 x, char minval, char maxval);
uchar3 const_func __attribute__((overloadable)) clamp(uchar3 x, uchar minval, uchar maxval);
char4 const_func __attribute__((overloadable)) clamp(char4 x, char minval, char maxval);
uchar4 const_func __attribute__((overloadable)) clamp(uchar4 x, uchar minval, uchar maxval);
char8 const_func __attribute__((overloadable)) clamp(char8 x, char minval, char maxval);
uchar8 const_func __attribute__((overloadable)) clamp(uchar8 x, uchar minval, uchar maxval);
char16 const_func __attribute__((overloadable)) clamp(char16 x, char minval, char maxval);
uchar16 const_func __attribute__((overloadable)) clamp(uchar16 x, uchar minval, uchar maxval);
short const_func __attribute__((overloadable)) clamp(short x, short minval, short maxval);
ushort const_func __attribute__((overloadable)) clamp(ushort x, ushort minval, ushort maxval);
short2 const_func __attribute__((overloadable)) clamp(short2 x, short minval, short maxval);
ushort2 const_func __attribute__((overloadable)) clamp(ushort2 x, ushort minval, ushort maxval);
short3 const_func __attribute__((overloadable)) clamp(short3 x, short minval, short maxval);
ushort3 const_func __attribute__((overloadable)) clamp(ushort3 x, ushort minval, ushort maxval);
short4 const_func __attribute__((overloadable)) clamp(short4 x, short minval, short maxval);
ushort4 const_func __attribute__((overloadable)) clamp(ushort4 x, ushort minval, ushort maxval);
short8 const_func __attribute__((overloadable)) clamp(short8 x, short minval, short maxval);
ushort8 const_func __attribute__((overloadable)) clamp(ushort8 x, ushort minval, ushort maxval);
short16 const_func __attribute__((overloadable)) clamp(short16 x, short minval, short maxval);
ushort16 const_func __attribute__((overloadable)) clamp(ushort16 x, ushort minval, ushort maxval);
int const_func __attribute__((overloadable)) clamp(int x, int minval, int maxval);
uint const_func __attribute__((overloadable)) clamp(uint x, uint minval, uint maxval);
int2 const_func __attribute__((overloadable)) clamp(int2 x, int minval, int maxval);
uint2 const_func __attribute__((overloadable)) clamp(uint2 x, uint minval, uint maxval);
int3 const_func __attribute__((overloadable)) clamp(int3 x, int minval, int maxval);
uint3 const_func __attribute__((overloadable)) clamp(uint3 x, uint minval, uint maxval);
int4 const_func __attribute__((overloadable)) clamp(int4 x, int minval, int maxval);
uint4 const_func __attribute__((overloadable)) clamp(uint4 x, uint minval, uint maxval);
int8 const_func __attribute__((overloadable)) clamp(int8 x, int minval, int maxval);
uint8 const_func __attribute__((overloadable)) clamp(uint8 x, uint minval, uint maxval);
int16 const_func __attribute__((overloadable)) clamp(int16 x, int minval, int maxval);
uint16 const_func __attribute__((overloadable)) clamp(uint16 x, uint minval, uint maxval);
long const_func __attribute__((overloadable)) clamp(long x, long minval, long maxval);
ulong const_func __attribute__((overloadable)) clamp(ulong x, ulong minval, ulong maxval);
long2 const_func __attribute__((overloadable)) clamp(long2 x, long minval, long maxval);
ulong2 const_func __attribute__((overloadable)) clamp(ulong2 x, ulong minval, ulong maxval);
long3 const_func __attribute__((overloadable)) clamp(long3 x, long minval, long maxval);
ulong3 const_func __attribute__((overloadable)) clamp(ulong3 x, ulong minval, ulong maxval);
long4 const_func __attribute__((overloadable)) clamp(long4 x, long minval, long maxval);
ulong4 const_func __attribute__((overloadable)) clamp(ulong4 x, ulong minval, ulong maxval);
long8 const_func __attribute__((overloadable)) clamp(long8 x, long minval, long maxval);
ulong8 const_func __attribute__((overloadable)) clamp(ulong8 x, ulong minval, ulong maxval);
long16 const_func __attribute__((overloadable)) clamp(long16 x, long minval, long maxval);
ulong16 const_func __attribute__((overloadable)) clamp(ulong16 x, ulong minval, ulong maxval);
/**
* Returns the number of leading 0-bits in x, starting
* at the most significant bit position.
*/
char const_func __attribute__((overloadable)) clz(char x);
uchar const_func __attribute__((overloadable)) clz(uchar x);
char2 const_func __attribute__((overloadable)) clz(char2 x);
uchar2 const_func __attribute__((overloadable)) clz(uchar2 x);
char3 const_func __attribute__((overloadable)) clz(char3 x);
uchar3 const_func __attribute__((overloadable)) clz(uchar3 x);
char4 const_func __attribute__((overloadable)) clz(char4 x);
uchar4 const_func __attribute__((overloadable)) clz(uchar4 x);
char8 const_func __attribute__((overloadable)) clz(char8 x);
uchar8 const_func __attribute__((overloadable)) clz(uchar8 x);
char16 const_func __attribute__((overloadable)) clz(char16 x);
uchar16 const_func __attribute__((overloadable)) clz(uchar16 x);
short const_func __attribute__((overloadable)) clz(short x);
ushort const_func __attribute__((overloadable)) clz(ushort x);
short2 const_func __attribute__((overloadable)) clz(short2 x);
ushort2 const_func __attribute__((overloadable)) clz(ushort2 x);
short3 const_func __attribute__((overloadable)) clz(short3 x);
ushort3 const_func __attribute__((overloadable)) clz(ushort3 x);
short4 const_func __attribute__((overloadable)) clz(short4 x);
ushort4 const_func __attribute__((overloadable)) clz(ushort4 x);
short8 const_func __attribute__((overloadable)) clz(short8 x);
ushort8 const_func __attribute__((overloadable)) clz(ushort8 x);
short16 const_func __attribute__((overloadable)) clz(short16 x);
ushort16 const_func __attribute__((overloadable)) clz(ushort16 x);
int const_func __attribute__((overloadable)) clz(int x);
uint const_func __attribute__((overloadable)) clz(uint x);
int2 const_func __attribute__((overloadable)) clz(int2 x);
uint2 const_func __attribute__((overloadable)) clz(uint2 x);
int3 const_func __attribute__((overloadable)) clz(int3 x);
uint3 const_func __attribute__((overloadable)) clz(uint3 x);
int4 const_func __attribute__((overloadable)) clz(int4 x);
uint4 const_func __attribute__((overloadable)) clz(uint4 x);
int8 const_func __attribute__((overloadable)) clz(int8 x);
uint8 const_func __attribute__((overloadable)) clz(uint8 x);
int16 const_func __attribute__((overloadable)) clz(int16 x);
uint16 const_func __attribute__((overloadable)) clz(uint16 x);
long const_func __attribute__((overloadable)) clz(long x);
ulong const_func __attribute__((overloadable)) clz(ulong x);
long2 const_func __attribute__((overloadable)) clz(long2 x);
ulong2 const_func __attribute__((overloadable)) clz(ulong2 x);
long3 const_func __attribute__((overloadable)) clz(long3 x);
ulong3 const_func __attribute__((overloadable)) clz(ulong3 x);
long4 const_func __attribute__((overloadable)) clz(long4 x);
ulong4 const_func __attribute__((overloadable)) clz(ulong4 x);
long8 const_func __attribute__((overloadable)) clz(long8 x);
ulong8 const_func __attribute__((overloadable)) clz(ulong8 x);
long16 const_func __attribute__((overloadable)) clz(long16 x);
ulong16 const_func __attribute__((overloadable)) clz(ulong16 x);
/**
* Returns mul_hi(a, b) + c.
*/
char const_func __attribute__((overloadable)) mad_hi(char a, char b, char c);
uchar const_func __attribute__((overloadable)) mad_hi(uchar a, uchar b, uchar c);
char2 const_func __attribute__((overloadable)) mad_hi(char2 a, char2 b, char2 c);
uchar2 const_func __attribute__((overloadable)) mad_hi(uchar2 a, uchar2 b, uchar2 c);
char3 const_func __attribute__((overloadable)) mad_hi(char3 a, char3 b, char3 c);
uchar3 const_func __attribute__((overloadable)) mad_hi(uchar3 a, uchar3 b, uchar3 c);
char4 const_func __attribute__((overloadable)) mad_hi(char4 a, char4 b, char4 c);
uchar4 const_func __attribute__((overloadable)) mad_hi(uchar4 a, uchar4 b, uchar4 c);
char8 const_func __attribute__((overloadable)) mad_hi(char8 a, char8 b, char8 c);
uchar8 const_func __attribute__((overloadable)) mad_hi(uchar8 a, uchar8 b, uchar8 c);
char16 const_func __attribute__((overloadable)) mad_hi(char16 a, char16 b, char16 c);
uchar16 const_func __attribute__((overloadable)) mad_hi(uchar16 a, uchar16 b, uchar16 c);
short const_func __attribute__((overloadable)) mad_hi(short a, short b, short c);
ushort const_func __attribute__((overloadable)) mad_hi(ushort a, ushort b, ushort c);
short2 const_func __attribute__((overloadable)) mad_hi(short2 a, short2 b, short2 c);
ushort2 const_func __attribute__((overloadable)) mad_hi(ushort2 a, ushort2 b, ushort2 c);
short3 const_func __attribute__((overloadable)) mad_hi(short3 a, short3 b, short3 c);
ushort3 const_func __attribute__((overloadable)) mad_hi(ushort3 a, ushort3 b, ushort3 c);
short4 const_func __attribute__((overloadable)) mad_hi(short4 a, short4 b, short4 c);
ushort4 const_func __attribute__((overloadable)) mad_hi(ushort4 a, ushort4 b, ushort4 c);
short8 const_func __attribute__((overloadable)) mad_hi(short8 a, short8 b, short8 c);
ushort8 const_func __attribute__((overloadable)) mad_hi(ushort8 a, ushort8 b, ushort8 c);
short16 const_func __attribute__((overloadable)) mad_hi(short16 a, short16 b, short16 c);
ushort16 const_func __attribute__((overloadable)) mad_hi(ushort16 a, ushort16 b, ushort16 c);
int const_func __attribute__((overloadable)) mad_hi(int a, int b, int c);
uint const_func __attribute__((overloadable)) mad_hi(uint a, uint b, uint c);
int2 const_func __attribute__((overloadable)) mad_hi(int2 a, int2 b, int2 c);
uint2 const_func __attribute__((overloadable)) mad_hi(uint2 a, uint2 b, uint2 c);
int3 const_func __attribute__((overloadable)) mad_hi(int3 a, int3 b, int3 c);
uint3 const_func __attribute__((overloadable)) mad_hi(uint3 a, uint3 b, uint3 c);
int4 const_func __attribute__((overloadable)) mad_hi(int4 a, int4 b, int4 c);
uint4 const_func __attribute__((overloadable)) mad_hi(uint4 a, uint4 b, uint4 c);
int8 const_func __attribute__((overloadable)) mad_hi(int8 a, int8 b, int8 c);
uint8 const_func __attribute__((overloadable)) mad_hi(uint8 a, uint8 b, uint8 c);
int16 const_func __attribute__((overloadable)) mad_hi(int16 a, int16 b, int16 c);
uint16 const_func __attribute__((overloadable)) mad_hi(uint16 a, uint16 b, uint16 c);
long const_func __attribute__((overloadable)) mad_hi(long a, long b, long c);
ulong const_func __attribute__((overloadable)) mad_hi(ulong a, ulong b, ulong c);
long2 const_func __attribute__((overloadable)) mad_hi(long2 a, long2 b, long2 c);
ulong2 const_func __attribute__((overloadable)) mad_hi(ulong2 a, ulong2 b, ulong2 c);
long3 const_func __attribute__((overloadable)) mad_hi(long3 a, long3 b, long3 c);
ulong3 const_func __attribute__((overloadable)) mad_hi(ulong3 a, ulong3 b, ulong3 c);
long4 const_func __attribute__((overloadable)) mad_hi(long4 a, long4 b, long4 c);
ulong4 const_func __attribute__((overloadable)) mad_hi(ulong4 a, ulong4 b, ulong4 c);
long8 const_func __attribute__((overloadable)) mad_hi(long8 a, long8 b, long8 c);
ulong8 const_func __attribute__((overloadable)) mad_hi(ulong8 a, ulong8 b, ulong8 c);
long16 const_func __attribute__((overloadable)) mad_hi(long16 a, long16 b, long16 c);
ulong16 const_func __attribute__((overloadable)) mad_hi(ulong16 a, ulong16 b, ulong16 c);
/**
* Returns a * b + c and saturates the result.
*/
char const_func __attribute__((overloadable)) mad_sat(char a, char b, char c);
uchar const_func __attribute__((overloadable)) mad_sat(uchar a, uchar b, uchar c);
char2 const_func __attribute__((overloadable)) mad_sat(char2 a, char2 b, char2 c);
uchar2 const_func __attribute__((overloadable)) mad_sat(uchar2 a, uchar2 b, uchar2 c);
char3 const_func __attribute__((overloadable)) mad_sat(char3 a, char3 b, char3 c);
uchar3 const_func __attribute__((overloadable)) mad_sat(uchar3 a, uchar3 b, uchar3 c);
char4 const_func __attribute__((overloadable)) mad_sat(char4 a, char4 b, char4 c);
uchar4 const_func __attribute__((overloadable)) mad_sat(uchar4 a, uchar4 b, uchar4 c);
char8 const_func __attribute__((overloadable)) mad_sat(char8 a, char8 b, char8 c);
uchar8 const_func __attribute__((overloadable)) mad_sat(uchar8 a, uchar8 b, uchar8 c);
char16 const_func __attribute__((overloadable)) mad_sat(char16 a, char16 b, char16 c);
uchar16 const_func __attribute__((overloadable)) mad_sat(uchar16 a, uchar16 b, uchar16 c);
short const_func __attribute__((overloadable)) mad_sat(short a, short b, short c);
ushort const_func __attribute__((overloadable)) mad_sat(ushort a, ushort b, ushort c);
short2 const_func __attribute__((overloadable)) mad_sat(short2 a, short2 b, short2 c);
ushort2 const_func __attribute__((overloadable)) mad_sat(ushort2 a, ushort2 b, ushort2 c);
short3 const_func __attribute__((overloadable)) mad_sat(short3 a, short3 b, short3 c);
ushort3 const_func __attribute__((overloadable)) mad_sat(ushort3 a, ushort3 b, ushort3 c);
short4 const_func __attribute__((overloadable)) mad_sat(short4 a, short4 b, short4 c);
ushort4 const_func __attribute__((overloadable)) mad_sat(ushort4 a, ushort4 b, ushort4 c);
short8 const_func __attribute__((overloadable)) mad_sat(short8 a, short8 b, short8 c);
ushort8 const_func __attribute__((overloadable)) mad_sat(ushort8 a, ushort8 b, ushort8 c);
short16 const_func __attribute__((overloadable)) mad_sat(short16 a, short16 b, short16 c);
ushort16 const_func __attribute__((overloadable)) mad_sat(ushort16 a, ushort16 b, ushort16 c);
int const_func __attribute__((overloadable)) mad_sat(int a, int b, int c);
uint const_func __attribute__((overloadable)) mad_sat(uint a, uint b, uint c);
int2 const_func __attribute__((overloadable)) mad_sat(int2 a, int2 b, int2 c);
uint2 const_func __attribute__((overloadable)) mad_sat(uint2 a, uint2 b, uint2 c);
int3 const_func __attribute__((overloadable)) mad_sat(int3 a, int3 b, int3 c);
uint3 const_func __attribute__((overloadable)) mad_sat(uint3 a, uint3 b, uint3 c);
int4 const_func __attribute__((overloadable)) mad_sat(int4 a, int4 b, int4 c);
uint4 const_func __attribute__((overloadable)) mad_sat(uint4 a, uint4 b, uint4 c);
int8 const_func __attribute__((overloadable)) mad_sat(int8 a, int8 b, int8 c);
uint8 const_func __attribute__((overloadable)) mad_sat(uint8 a, uint8 b, uint8 c);
int16 const_func __attribute__((overloadable)) mad_sat(int16 a, int16 b, int16 c);
uint16 const_func __attribute__((overloadable)) mad_sat(uint16 a, uint16 b, uint16 c);
long const_func __attribute__((overloadable)) mad_sat(long a, long b, long c);
ulong const_func __attribute__((overloadable)) mad_sat(ulong a, ulong b, ulong c);
long2 const_func __attribute__((overloadable)) mad_sat(long2 a, long2 b, long2 c);
ulong2 const_func __attribute__((overloadable)) mad_sat(ulong2 a, ulong2 b, ulong2 c);
long3 const_func __attribute__((overloadable)) mad_sat(long3 a, long3 b, long3 c);
ulong3 const_func __attribute__((overloadable)) mad_sat(ulong3 a, ulong3 b, ulong3 c);
long4 const_func __attribute__((overloadable)) mad_sat(long4 a, long4 b, long4 c);
ulong4 const_func __attribute__((overloadable)) mad_sat(ulong4 a, ulong4 b, ulong4 c);
long8 const_func __attribute__((overloadable)) mad_sat(long8 a, long8 b, long8 c);
ulong8 const_func __attribute__((overloadable)) mad_sat(ulong8 a, ulong8 b, ulong8 c);
long16 const_func __attribute__((overloadable)) mad_sat(long16 a, long16 b, long16 c);
ulong16 const_func __attribute__((overloadable)) mad_sat(ulong16 a, ulong16 b, ulong16 c);
/**
* Returns y if x < y, otherwise it returns x.
*/
char const_func __attribute__((overloadable)) max(char x, char y);
uchar const_func __attribute__((overloadable)) max(uchar x, uchar y);
char2 const_func __attribute__((overloadable)) max(char2 x, char2 y);
uchar2 const_func __attribute__((overloadable)) max(uchar2 x, uchar2 y);
char3 const_func __attribute__((overloadable)) max(char3 x, char3 y);
uchar3 const_func __attribute__((overloadable)) max(uchar3 x, uchar3 y);
char4 const_func __attribute__((overloadable)) max(char4 x, char4 y);
uchar4 const_func __attribute__((overloadable)) max(uchar4 x, uchar4 y);
char8 const_func __attribute__((overloadable)) max(char8 x, char8 y);
uchar8 const_func __attribute__((overloadable)) max(uchar8 x, uchar8 y);
char16 const_func __attribute__((overloadable)) max(char16 x, char16 y);
uchar16 const_func __attribute__((overloadable)) max(uchar16 x, uchar16 y);
short const_func __attribute__((overloadable)) max(short x, short y);
ushort const_func __attribute__((overloadable)) max(ushort x, ushort y);
short2 const_func __attribute__((overloadable)) max(short2 x, short2 y);
ushort2 const_func __attribute__((overloadable)) max(ushort2 x, ushort2 y);
short3 const_func __attribute__((overloadable)) max(short3 x, short3 y);
ushort3 const_func __attribute__((overloadable)) max(ushort3 x, ushort3 y);
short4 const_func __attribute__((overloadable)) max(short4 x, short4 y);
ushort4 const_func __attribute__((overloadable)) max(ushort4 x, ushort4 y);
short8 const_func __attribute__((overloadable)) max(short8 x, short8 y);
ushort8 const_func __attribute__((overloadable)) max(ushort8 x, ushort8 y);
short16 const_func __attribute__((overloadable)) max(short16 x, short16 y);
ushort16 const_func __attribute__((overloadable)) max(ushort16 x, ushort16 y);
int const_func __attribute__((overloadable)) max(int x, int y);
uint const_func __attribute__((overloadable)) max(uint x, uint y);
int2 const_func __attribute__((overloadable)) max(int2 x, int2 y);
uint2 const_func __attribute__((overloadable)) max(uint2 x, uint2 y);
int3 const_func __attribute__((overloadable)) max(int3 x, int3 y);
uint3 const_func __attribute__((overloadable)) max(uint3 x, uint3 y);
int4 const_func __attribute__((overloadable)) max(int4 x, int4 y);
uint4 const_func __attribute__((overloadable)) max(uint4 x, uint4 y);
int8 const_func __attribute__((overloadable)) max(int8 x, int8 y);
uint8 const_func __attribute__((overloadable)) max(uint8 x, uint8 y);
int16 const_func __attribute__((overloadable)) max(int16 x, int16 y);
uint16 const_func __attribute__((overloadable)) max(uint16 x, uint16 y);
long const_func __attribute__((overloadable)) max(long x, long y);
ulong const_func __attribute__((overloadable)) max(ulong x, ulong y);
long2 const_func __attribute__((overloadable)) max(long2 x, long2 y);
ulong2 const_func __attribute__((overloadable)) max(ulong2 x, ulong2 y);
long3 const_func __attribute__((overloadable)) max(long3 x, long3 y);
ulong3 const_func __attribute__((overloadable)) max(ulong3 x, ulong3 y);
long4 const_func __attribute__((overloadable)) max(long4 x, long4 y);
ulong4 const_func __attribute__((overloadable)) max(ulong4 x, ulong4 y);
long8 const_func __attribute__((overloadable)) max(long8 x, long8 y);
ulong8 const_func __attribute__((overloadable)) max(ulong8 x, ulong8 y);
long16 const_func __attribute__((overloadable)) max(long16 x, long16 y);
ulong16 const_func __attribute__((overloadable)) max(ulong16 x, ulong16 y);
char const_func __attribute__((overloadable)) max(char x, char y);
uchar const_func __attribute__((overloadable)) max(uchar x, uchar y);
char2 const_func __attribute__((overloadable)) max(char2 x, char y);
uchar2 const_func __attribute__((overloadable)) max(uchar2 x, uchar y);
char3 const_func __attribute__((overloadable)) max(char3 x, char y);
uchar3 const_func __attribute__((overloadable)) max(uchar3 x, uchar y);
char4 const_func __attribute__((overloadable)) max(char4 x, char y);
uchar4 const_func __attribute__((overloadable)) max(uchar4 x, uchar y);
char8 const_func __attribute__((overloadable)) max(char8 x, char y);
uchar8 const_func __attribute__((overloadable)) max(uchar8 x, uchar y);
char16 const_func __attribute__((overloadable)) max(char16 x, char y);
uchar16 const_func __attribute__((overloadable)) max(uchar16 x, uchar y);
short const_func __attribute__((overloadable)) max(short x, short y);
ushort const_func __attribute__((overloadable)) max(ushort x, ushort y);
short2 const_func __attribute__((overloadable)) max(short2 x, short y);
ushort2 const_func __attribute__((overloadable)) max(ushort2 x, ushort y);
short3 const_func __attribute__((overloadable)) max(short3 x, short y);
ushort3 const_func __attribute__((overloadable)) max(ushort3 x, ushort y);
short4 const_func __attribute__((overloadable)) max(short4 x, short y);
ushort4 const_func __attribute__((overloadable)) max(ushort4 x, ushort y);
short8 const_func __attribute__((overloadable)) max(short8 x, short y);
ushort8 const_func __attribute__((overloadable)) max(ushort8 x, ushort y);
short16 const_func __attribute__((overloadable)) max(short16 x, short y);
ushort16 const_func __attribute__((overloadable)) max(ushort16 x, ushort y);
int const_func __attribute__((overloadable)) max(int x, int y);
uint const_func __attribute__((overloadable)) max(uint x, uint y);
int2 const_func __attribute__((overloadable)) max(int2 x, int y);
uint2 const_func __attribute__((overloadable)) max(uint2 x, uint y);
int3 const_func __attribute__((overloadable)) max(int3 x, int y);
uint3 const_func __attribute__((overloadable)) max(uint3 x, uint y);
int4 const_func __attribute__((overloadable)) max(int4 x, int y);
uint4 const_func __attribute__((overloadable)) max(uint4 x, uint y);
int8 const_func __attribute__((overloadable)) max(int8 x, int y);
uint8 const_func __attribute__((overloadable)) max(uint8 x, uint y);
int16 const_func __attribute__((overloadable)) max(int16 x, int y);
uint16 const_func __attribute__((overloadable)) max(uint16 x, uint y);
long const_func __attribute__((overloadable)) max(long x, long y);
ulong const_func __attribute__((overloadable)) max(ulong x, ulong y);
long2 const_func __attribute__((overloadable)) max(long2 x, long y);
ulong2 const_func __attribute__((overloadable)) max(ulong2 x, ulong y);
long3 const_func __attribute__((overloadable)) max(long3 x, long y);
ulong3 const_func __attribute__((overloadable)) max(ulong3 x, ulong y);
long4 const_func __attribute__((overloadable)) max(long4 x, long y);
ulong4 const_func __attribute__((overloadable)) max(ulong4 x, ulong y);
long8 const_func __attribute__((overloadable)) max(long8 x, long y);
ulong8 const_func __attribute__((overloadable)) max(ulong8 x, ulong y);
long16 const_func __attribute__((overloadable)) max(long16 x, long y);
ulong16 const_func __attribute__((overloadable)) max(ulong16 x, ulong y);
/**
* Returns y if y < x, otherwise it returns x.
*/
char const_func __attribute__((overloadable)) min(char x, char y);
uchar const_func __attribute__((overloadable)) min(uchar x, uchar y);
char2 const_func __attribute__((overloadable)) min(char2 x, char2 y);
uchar2 const_func __attribute__((overloadable)) min(uchar2 x, uchar2 y);
char3 const_func __attribute__((overloadable)) min(char3 x, char3 y);
uchar3 const_func __attribute__((overloadable)) min(uchar3 x, uchar3 y);
char4 const_func __attribute__((overloadable)) min(char4 x, char4 y);
uchar4 const_func __attribute__((overloadable)) min(uchar4 x, uchar4 y);
char8 const_func __attribute__((overloadable)) min(char8 x, char8 y);
uchar8 const_func __attribute__((overloadable)) min(uchar8 x, uchar8 y);
char16 const_func __attribute__((overloadable)) min(char16 x, char16 y);
uchar16 const_func __attribute__((overloadable)) min(uchar16 x, uchar16 y);
short const_func __attribute__((overloadable)) min(short x, short y);
ushort const_func __attribute__((overloadable)) min(ushort x, ushort y);
short2 const_func __attribute__((overloadable)) min(short2 x, short2 y);
ushort2 const_func __attribute__((overloadable)) min(ushort2 x, ushort2 y);
short3 const_func __attribute__((overloadable)) min(short3 x, short3 y);
ushort3 const_func __attribute__((overloadable)) min(ushort3 x, ushort3 y);
short4 const_func __attribute__((overloadable)) min(short4 x, short4 y);
ushort4 const_func __attribute__((overloadable)) min(ushort4 x, ushort4 y);
short8 const_func __attribute__((overloadable)) min(short8 x, short8 y);
ushort8 const_func __attribute__((overloadable)) min(ushort8 x, ushort8 y);
short16 const_func __attribute__((overloadable)) min(short16 x, short16 y);
ushort16 const_func __attribute__((overloadable)) min(ushort16 x, ushort16 y);
int const_func __attribute__((overloadable)) min(int x, int y);
uint const_func __attribute__((overloadable)) min(uint x, uint y);
int2 const_func __attribute__((overloadable)) min(int2 x, int2 y);
uint2 const_func __attribute__((overloadable)) min(uint2 x, uint2 y);
int3 const_func __attribute__((overloadable)) min(int3 x, int3 y);
uint3 const_func __attribute__((overloadable)) min(uint3 x, uint3 y);
int4 const_func __attribute__((overloadable)) min(int4 x, int4 y);
uint4 const_func __attribute__((overloadable)) min(uint4 x, uint4 y);
int8 const_func __attribute__((overloadable)) min(int8 x, int8 y);
uint8 const_func __attribute__((overloadable)) min(uint8 x, uint8 y);
int16 const_func __attribute__((overloadable)) min(int16 x, int16 y);
uint16 const_func __attribute__((overloadable)) min(uint16 x, uint16 y);
long const_func __attribute__((overloadable)) min(long x, long y);
ulong const_func __attribute__((overloadable)) min(ulong x, ulong y);
long2 const_func __attribute__((overloadable)) min(long2 x, long2 y);
ulong2 const_func __attribute__((overloadable)) min(ulong2 x, ulong2 y);
long3 const_func __attribute__((overloadable)) min(long3 x, long3 y);
ulong3 const_func __attribute__((overloadable)) min(ulong3 x, ulong3 y);
long4 const_func __attribute__((overloadable)) min(long4 x, long4 y);
ulong4 const_func __attribute__((overloadable)) min(ulong4 x, ulong4 y);
long8 const_func __attribute__((overloadable)) min(long8 x, long8 y);
ulong8 const_func __attribute__((overloadable)) min(ulong8 x, ulong8 y);
long16 const_func __attribute__((overloadable)) min(long16 x, long16 y);
ulong16 const_func __attribute__((overloadable)) min(ulong16 x, ulong16 y);
char const_func __attribute__((overloadable)) min(char x, char y);
uchar const_func __attribute__((overloadable)) min(uchar x, uchar y);
char2 const_func __attribute__((overloadable)) min(char2 x, char y);
uchar2 const_func __attribute__((overloadable)) min(uchar2 x, uchar y);
char3 const_func __attribute__((overloadable)) min(char3 x, char y);
uchar3 const_func __attribute__((overloadable)) min(uchar3 x, uchar y);
char4 const_func __attribute__((overloadable)) min(char4 x, char y);
uchar4 const_func __attribute__((overloadable)) min(uchar4 x, uchar y);
char8 const_func __attribute__((overloadable)) min(char8 x, char y);
uchar8 const_func __attribute__((overloadable)) min(uchar8 x, uchar y);
char16 const_func __attribute__((overloadable)) min(char16 x, char y);
uchar16 const_func __attribute__((overloadable)) min(uchar16 x, uchar y);
short const_func __attribute__((overloadable)) min(short x, short y);
ushort const_func __attribute__((overloadable)) min(ushort x, ushort y);
short2 const_func __attribute__((overloadable)) min(short2 x, short y);
ushort2 const_func __attribute__((overloadable)) min(ushort2 x, ushort y);
short3 const_func __attribute__((overloadable)) min(short3 x, short y);
ushort3 const_func __attribute__((overloadable)) min(ushort3 x, ushort y);
short4 const_func __attribute__((overloadable)) min(short4 x, short y);
ushort4 const_func __attribute__((overloadable)) min(ushort4 x, ushort y);
short8 const_func __attribute__((overloadable)) min(short8 x, short y);
ushort8 const_func __attribute__((overloadable)) min(ushort8 x, ushort y);
short16 const_func __attribute__((overloadable)) min(short16 x, short y);
ushort16 const_func __attribute__((overloadable)) min(ushort16 x, ushort y);
int const_func __attribute__((overloadable)) min(int x, int y);
uint const_func __attribute__((overloadable)) min(uint x, uint y);
int2 const_func __attribute__((overloadable)) min(int2 x, int y);
uint2 const_func __attribute__((overloadable)) min(uint2 x, uint y);
int3 const_func __attribute__((overloadable)) min(int3 x, int y);
uint3 const_func __attribute__((overloadable)) min(uint3 x, uint y);
int4 const_func __attribute__((overloadable)) min(int4 x, int y);
uint4 const_func __attribute__((overloadable)) min(uint4 x, uint y);
int8 const_func __attribute__((overloadable)) min(int8 x, int y);
uint8 const_func __attribute__((overloadable)) min(uint8 x, uint y);
int16 const_func __attribute__((overloadable)) min(int16 x, int y);
uint16 const_func __attribute__((overloadable)) min(uint16 x, uint y);
long const_func __attribute__((overloadable)) min(long x, long y);
ulong const_func __attribute__((overloadable)) min(ulong x, ulong y);
long2 const_func __attribute__((overloadable)) min(long2 x, long y);
ulong2 const_func __attribute__((overloadable)) min(ulong2 x, ulong y);
long3 const_func __attribute__((overloadable)) min(long3 x, long y);
ulong3 const_func __attribute__((overloadable)) min(ulong3 x, ulong y);
long4 const_func __attribute__((overloadable)) min(long4 x, long y);
ulong4 const_func __attribute__((overloadable)) min(ulong4 x, ulong y);
long8 const_func __attribute__((overloadable)) min(long8 x, long y);
ulong8 const_func __attribute__((overloadable)) min(ulong8 x, ulong y);
long16 const_func __attribute__((overloadable)) min(long16 x, long y);
ulong16 const_func __attribute__((overloadable)) min(ulong16 x, ulong y);
/**
* Computes x * y and returns the high half of the
* product of x and y.
*/
char const_func __attribute__((overloadable)) mul_hi(char x, char y);
uchar const_func __attribute__((overloadable)) mul_hi(uchar x, uchar y);
char2 const_func __attribute__((overloadable)) mul_hi(char2 x, char2 y);
uchar2 const_func __attribute__((overloadable)) mul_hi(uchar2 x, uchar2 y);
char3 const_func __attribute__((overloadable)) mul_hi(char3 x, char3 y);
uchar3 const_func __attribute__((overloadable)) mul_hi(uchar3 x, uchar3 y);
char4 const_func __attribute__((overloadable)) mul_hi(char4 x, char4 y);
uchar4 const_func __attribute__((overloadable)) mul_hi(uchar4 x, uchar4 y);
char8 const_func __attribute__((overloadable)) mul_hi(char8 x, char8 y);
uchar8 const_func __attribute__((overloadable)) mul_hi(uchar8 x, uchar8 y);
char16 const_func __attribute__((overloadable)) mul_hi(char16 x, char16 y);
uchar16 const_func __attribute__((overloadable)) mul_hi(uchar16 x, uchar16 y);
short const_func __attribute__((overloadable)) mul_hi(short x, short y);
ushort const_func __attribute__((overloadable)) mul_hi(ushort x, ushort y);
short2 const_func __attribute__((overloadable)) mul_hi(short2 x, short2 y);
ushort2 const_func __attribute__((overloadable)) mul_hi(ushort2 x, ushort2 y);
short3 const_func __attribute__((overloadable)) mul_hi(short3 x, short3 y);
ushort3 const_func __attribute__((overloadable)) mul_hi(ushort3 x, ushort3 y);
short4 const_func __attribute__((overloadable)) mul_hi(short4 x, short4 y);
ushort4 const_func __attribute__((overloadable)) mul_hi(ushort4 x, ushort4 y);
short8 const_func __attribute__((overloadable)) mul_hi(short8 x, short8 y);
ushort8 const_func __attribute__((overloadable)) mul_hi(ushort8 x, ushort8 y);
short16 const_func __attribute__((overloadable)) mul_hi(short16 x, short16 y);
ushort16 const_func __attribute__((overloadable)) mul_hi(ushort16 x, ushort16 y);
int const_func __attribute__((overloadable)) mul_hi(int x, int y);
uint const_func __attribute__((overloadable)) mul_hi(uint x, uint y);
int2 const_func __attribute__((overloadable)) mul_hi(int2 x, int2 y);
uint2 const_func __attribute__((overloadable)) mul_hi(uint2 x, uint2 y);
int3 const_func __attribute__((overloadable)) mul_hi(int3 x, int3 y);
uint3 const_func __attribute__((overloadable)) mul_hi(uint3 x, uint3 y);
int4 const_func __attribute__((overloadable)) mul_hi(int4 x, int4 y);
uint4 const_func __attribute__((overloadable)) mul_hi(uint4 x, uint4 y);
int8 const_func __attribute__((overloadable)) mul_hi(int8 x, int8 y);
uint8 const_func __attribute__((overloadable)) mul_hi(uint8 x, uint8 y);
int16 const_func __attribute__((overloadable)) mul_hi(int16 x, int16 y);
uint16 const_func __attribute__((overloadable)) mul_hi(uint16 x, uint16 y);
long const_func __attribute__((overloadable)) mul_hi(long x, long y);
ulong const_func __attribute__((overloadable)) mul_hi(ulong x, ulong y);
long2 const_func __attribute__((overloadable)) mul_hi(long2 x, long2 y);
ulong2 const_func __attribute__((overloadable)) mul_hi(ulong2 x, ulong2 y);
long3 const_func __attribute__((overloadable)) mul_hi(long3 x, long3 y);
ulong3 const_func __attribute__((overloadable)) mul_hi(ulong3 x, ulong3 y);
long4 const_func __attribute__((overloadable)) mul_hi(long4 x, long4 y);
ulong4 const_func __attribute__((overloadable)) mul_hi(ulong4 x, ulong4 y);
long8 const_func __attribute__((overloadable)) mul_hi(long8 x, long8 y);
ulong8 const_func __attribute__((overloadable)) mul_hi(ulong8 x, ulong8 y);
long16 const_func __attribute__((overloadable)) mul_hi(long16 x, long16 y);
ulong16 const_func __attribute__((overloadable)) mul_hi(ulong16 x, ulong16 y);
/**
* For each element in v, the bits are shifted left by
* the number of bits given by the corresponding
* element in i (subject to usual shift modulo rules
* described in section 6.3). Bits shifted off the left
* side of the element are shifted back in from the
* right.
*/
char const_func __attribute__((overloadable)) rotate(char v, char i);
uchar const_func __attribute__((overloadable)) rotate(uchar v, uchar i);
char2 const_func __attribute__((overloadable)) rotate(char2 v, char2 i);
uchar2 const_func __attribute__((overloadable)) rotate(uchar2 v, uchar2 i);
char3 const_func __attribute__((overloadable)) rotate(char3 v, char3 i);
uchar3 const_func __attribute__((overloadable)) rotate(uchar3 v, uchar3 i);
char4 const_func __attribute__((overloadable)) rotate(char4 v, char4 i);
uchar4 const_func __attribute__((overloadable)) rotate(uchar4 v, uchar4 i);
char8 const_func __attribute__((overloadable)) rotate(char8 v, char8 i);
uchar8 const_func __attribute__((overloadable)) rotate(uchar8 v, uchar8 i);
char16 const_func __attribute__((overloadable)) rotate(char16 v, char16 i);
uchar16 const_func __attribute__((overloadable)) rotate(uchar16 v, uchar16 i);
short const_func __attribute__((overloadable)) rotate(short v, short i);
ushort const_func __attribute__((overloadable)) rotate(ushort v, ushort i);
short2 const_func __attribute__((overloadable)) rotate(short2 v, short2 i);
ushort2 const_func __attribute__((overloadable)) rotate(ushort2 v, ushort2 i);
short3 const_func __attribute__((overloadable)) rotate(short3 v, short3 i);
ushort3 const_func __attribute__((overloadable)) rotate(ushort3 v, ushort3 i);
short4 const_func __attribute__((overloadable)) rotate(short4 v, short4 i);
ushort4 const_func __attribute__((overloadable)) rotate(ushort4 v, ushort4 i);
short8 const_func __attribute__((overloadable)) rotate(short8 v, short8 i);
ushort8 const_func __attribute__((overloadable)) rotate(ushort8 v, ushort8 i);
short16 const_func __attribute__((overloadable)) rotate(short16 v, short16 i);
ushort16 const_func __attribute__((overloadable)) rotate(ushort16 v, ushort16 i);
int const_func __attribute__((overloadable)) rotate(int v, int i);
uint const_func __attribute__((overloadable)) rotate(uint v, uint i);
int2 const_func __attribute__((overloadable)) rotate(int2 v, int2 i);
uint2 const_func __attribute__((overloadable)) rotate(uint2 v, uint2 i);
int3 const_func __attribute__((overloadable)) rotate(int3 v, int3 i);
uint3 const_func __attribute__((overloadable)) rotate(uint3 v, uint3 i);
int4 const_func __attribute__((overloadable)) rotate(int4 v, int4 i);
uint4 const_func __attribute__((overloadable)) rotate(uint4 v, uint4 i);
int8 const_func __attribute__((overloadable)) rotate(int8 v, int8 i);
uint8 const_func __attribute__((overloadable)) rotate(uint8 v, uint8 i);
int16 const_func __attribute__((overloadable)) rotate(int16 v, int16 i);
uint16 const_func __attribute__((overloadable)) rotate(uint16 v, uint16 i);
long const_func __attribute__((overloadable)) rotate(long v, long i);
ulong const_func __attribute__((overloadable)) rotate(ulong v, ulong i);
long2 const_func __attribute__((overloadable)) rotate(long2 v, long2 i);
ulong2 const_func __attribute__((overloadable)) rotate(ulong2 v, ulong2 i);
long3 const_func __attribute__((overloadable)) rotate(long3 v, long3 i);
ulong3 const_func __attribute__((overloadable)) rotate(ulong3 v, ulong3 i);
long4 const_func __attribute__((overloadable)) rotate(long4 v, long4 i);
ulong4 const_func __attribute__((overloadable)) rotate(ulong4 v, ulong4 i);
long8 const_func __attribute__((overloadable)) rotate(long8 v, long8 i);
ulong8 const_func __attribute__((overloadable)) rotate(ulong8 v, ulong8 i);
long16 const_func __attribute__((overloadable)) rotate(long16 v, long16 i);
ulong16 const_func __attribute__((overloadable)) rotate(ulong16 v, ulong16 i);
/**
* Returns x - y and saturates the result.
*/
char const_func __attribute__((overloadable)) sub_sat(char x, char y);
uchar const_func __attribute__((overloadable)) sub_sat(uchar x, uchar y);
char2 const_func __attribute__((overloadable)) sub_sat(char2 x, char2 y);
uchar2 const_func __attribute__((overloadable)) sub_sat(uchar2 x, uchar2 y);
char3 const_func __attribute__((overloadable)) sub_sat(char3 x, char3 y);
uchar3 const_func __attribute__((overloadable)) sub_sat(uchar3 x, uchar3 y);
char4 const_func __attribute__((overloadable)) sub_sat(char4 x, char4 y);
uchar4 const_func __attribute__((overloadable)) sub_sat(uchar4 x, uchar4 y);
char8 const_func __attribute__((overloadable)) sub_sat(char8 x, char8 y);
uchar8 const_func __attribute__((overloadable)) sub_sat(uchar8 x, uchar8 y);
char16 const_func __attribute__((overloadable)) sub_sat(char16 x, char16 y);
uchar16 const_func __attribute__((overloadable)) sub_sat(uchar16 x, uchar16 y);
short const_func __attribute__((overloadable)) sub_sat(short x, short y);
ushort const_func __attribute__((overloadable)) sub_sat(ushort x, ushort y);
short2 const_func __attribute__((overloadable)) sub_sat(short2 x, short2 y);
ushort2 const_func __attribute__((overloadable)) sub_sat(ushort2 x, ushort2 y);
short3 const_func __attribute__((overloadable)) sub_sat(short3 x, short3 y);
ushort3 const_func __attribute__((overloadable)) sub_sat(ushort3 x, ushort3 y);
short4 const_func __attribute__((overloadable)) sub_sat(short4 x, short4 y);
ushort4 const_func __attribute__((overloadable)) sub_sat(ushort4 x, ushort4 y);
short8 const_func __attribute__((overloadable)) sub_sat(short8 x, short8 y);
ushort8 const_func __attribute__((overloadable)) sub_sat(ushort8 x, ushort8 y);
short16 const_func __attribute__((overloadable)) sub_sat(short16 x, short16 y);
ushort16 const_func __attribute__((overloadable)) sub_sat(ushort16 x, ushort16 y);
int const_func __attribute__((overloadable)) sub_sat(int x, int y);
uint const_func __attribute__((overloadable)) sub_sat(uint x, uint y);
int2 const_func __attribute__((overloadable)) sub_sat(int2 x, int2 y);
uint2 const_func __attribute__((overloadable)) sub_sat(uint2 x, uint2 y);
int3 const_func __attribute__((overloadable)) sub_sat(int3 x, int3 y);
uint3 const_func __attribute__((overloadable)) sub_sat(uint3 x, uint3 y);
int4 const_func __attribute__((overloadable)) sub_sat(int4 x, int4 y);
uint4 const_func __attribute__((overloadable)) sub_sat(uint4 x, uint4 y);
int8 const_func __attribute__((overloadable)) sub_sat(int8 x, int8 y);
uint8 const_func __attribute__((overloadable)) sub_sat(uint8 x, uint8 y);
int16 const_func __attribute__((overloadable)) sub_sat(int16 x, int16 y);
uint16 const_func __attribute__((overloadable)) sub_sat(uint16 x, uint16 y);
long const_func __attribute__((overloadable)) sub_sat(long x, long y);
ulong const_func __attribute__((overloadable)) sub_sat(ulong x, ulong y);
long2 const_func __attribute__((overloadable)) sub_sat(long2 x, long2 y);
ulong2 const_func __attribute__((overloadable)) sub_sat(ulong2 x, ulong2 y);
long3 const_func __attribute__((overloadable)) sub_sat(long3 x, long3 y);
ulong3 const_func __attribute__((overloadable)) sub_sat(ulong3 x, ulong3 y);
long4 const_func __attribute__((overloadable)) sub_sat(long4 x, long4 y);
ulong4 const_func __attribute__((overloadable)) sub_sat(ulong4 x, ulong4 y);
long8 const_func __attribute__((overloadable)) sub_sat(long8 x, long8 y);
ulong8 const_func __attribute__((overloadable)) sub_sat(ulong8 x, ulong8 y);
long16 const_func __attribute__((overloadable)) sub_sat(long16 x, long16 y);
ulong16 const_func __attribute__((overloadable)) sub_sat(ulong16 x, ulong16 y);
/**
* result[i] = ((short)hi[i] << 8) | lo[i]
* result[i] = ((ushort)hi[i] << 8) | lo[i]
*/
short const_func __attribute__((overloadable)) upsample(char hi, uchar lo);
ushort const_func __attribute__((overloadable)) upsample (uchar hi, uchar lo);
short2 const_func __attribute__((overloadable)) upsample (char2 hi, uchar2 lo);
short3 const_func __attribute__((overloadable)) upsample (char3 hi, uchar3 lo);
short4 const_func __attribute__((overloadable)) upsample (char4 hi, uchar4 lo);
short8 const_func __attribute__((overloadable)) upsample (char8 hi, uchar8 lo);
short16 const_func __attribute__((overloadable)) upsample (char16 hi, uchar16 lo);
ushort2 const_func __attribute__((overloadable)) upsample (uchar2 hi, uchar2 lo);
ushort3 const_func __attribute__((overloadable)) upsample (uchar3 hi, uchar3 lo);
ushort4 const_func __attribute__((overloadable)) upsample (uchar4 hi, uchar4 lo);
ushort8 const_func __attribute__((overloadable)) upsample (uchar8 hi, uchar8 lo);
ushort16 const_func __attribute__((overloadable)) upsample (uchar16 hi, uchar16 lo);
/**
* result[i] = ((int)hi[i] << 16) | lo[i]
* result[i] = ((uint)hi[i] << 16) | lo[i]
*/
int const_func __attribute__((overloadable)) upsample(short hi, ushort lo);
uint const_func __attribute__((overloadable)) upsample (ushort hi, ushort lo);
int2 const_func __attribute__((overloadable)) upsample (short2 hi, ushort2 lo);
int3 const_func __attribute__((overloadable)) upsample (short3 hi, ushort3 lo);
int4 const_func __attribute__((overloadable)) upsample (short4 hi, ushort4 lo);
int8 const_func __attribute__((overloadable)) upsample (short8 hi, ushort8 lo);
int16 const_func __attribute__((overloadable)) upsample (short16 hi, ushort16 lo);
uint2 const_func __attribute__((overloadable)) upsample (ushort2 hi, ushort2 lo);
uint3 const_func __attribute__((overloadable)) upsample (ushort3 hi, ushort3 lo);
uint4 const_func __attribute__((overloadable)) upsample (ushort4 hi, ushort4 lo);
uint8 const_func __attribute__((overloadable)) upsample (ushort8 hi, ushort8 lo);
uint16 const_func __attribute__((overloadable)) upsample (ushort16 hi, ushort16 lo);
/**
* result[i] = ((long)hi[i] << 32) | lo[i]
* result[i] = ((ulong)hi[i] << 32) | lo[i]
*/
long const_func __attribute__((overloadable)) upsample(int hi, uint lo);
ulong const_func __attribute__((overloadable)) upsample (uint hi, uint lo);
long2 const_func __attribute__((overloadable)) upsample (int2 hi, uint2 lo);
long3 const_func __attribute__((overloadable)) upsample (int3 hi, uint3 lo);
long4 const_func __attribute__((overloadable)) upsample (int4 hi, uint4 lo);
long8 const_func __attribute__((overloadable)) upsample (int8 hi, uint8 lo);
long16 const_func __attribute__((overloadable)) upsample (int16 hi, uint16 lo);
ulong2 const_func __attribute__((overloadable)) upsample (uint2 hi, uint2 lo);
ulong3 const_func __attribute__((overloadable)) upsample (uint3 hi, uint3 lo);
ulong4 const_func __attribute__((overloadable)) upsample (uint4 hi, uint4 lo);
ulong8 const_func __attribute__((overloadable)) upsample (uint8 hi, uint8 lo);
ulong16 const_func __attribute__((overloadable)) upsample (uint16 hi, uint16 lo);
/*
* popcount(x): returns the number of set bit in x
*/
char const_func __attribute__((overloadable)) popcount(char x);
uchar const_func __attribute__((overloadable)) popcount(uchar x);
char2 const_func __attribute__((overloadable)) popcount(char2 x);
uchar2 const_func __attribute__((overloadable)) popcount(uchar2 x);
char3 const_func __attribute__((overloadable)) popcount(char3 x);
uchar3 const_func __attribute__((overloadable)) popcount(uchar3 x);
char4 const_func __attribute__((overloadable)) popcount(char4 x);
uchar4 const_func __attribute__((overloadable)) popcount(uchar4 x);
char8 const_func __attribute__((overloadable)) popcount(char8 x);
uchar8 const_func __attribute__((overloadable)) popcount(uchar8 x);
char16 const_func __attribute__((overloadable)) popcount(char16 x);
uchar16 const_func __attribute__((overloadable)) popcount(uchar16 x);
short const_func __attribute__((overloadable)) popcount(short x);
ushort const_func __attribute__((overloadable)) popcount(ushort x);
short2 const_func __attribute__((overloadable)) popcount(short2 x);
ushort2 const_func __attribute__((overloadable)) popcount(ushort2 x);
short3 const_func __attribute__((overloadable)) popcount(short3 x);
ushort3 const_func __attribute__((overloadable)) popcount(ushort3 x);
short4 const_func __attribute__((overloadable)) popcount(short4 x);
ushort4 const_func __attribute__((overloadable)) popcount(ushort4 x);
short8 const_func __attribute__((overloadable)) popcount(short8 x);
ushort8 const_func __attribute__((overloadable)) popcount(ushort8 x);
short16 const_func __attribute__((overloadable)) popcount(short16 x);
ushort16 const_func __attribute__((overloadable)) popcount(ushort16 x);
int const_func __attribute__((overloadable)) popcount(int x);
uint const_func __attribute__((overloadable)) popcount(uint x);
int2 const_func __attribute__((overloadable)) popcount(int2 x);
uint2 const_func __attribute__((overloadable)) popcount(uint2 x);
int3 const_func __attribute__((overloadable)) popcount(int3 x);
uint3 const_func __attribute__((overloadable)) popcount(uint3 x);
int4 const_func __attribute__((overloadable)) popcount(int4 x);
uint4 const_func __attribute__((overloadable)) popcount(uint4 x);
int8 const_func __attribute__((overloadable)) popcount(int8 x);
uint8 const_func __attribute__((overloadable)) popcount(uint8 x);
int16 const_func __attribute__((overloadable)) popcount(int16 x);
uint16 const_func __attribute__((overloadable)) popcount(uint16 x);
long const_func __attribute__((overloadable)) popcount(long x);
ulong const_func __attribute__((overloadable)) popcount(ulong x);
long2 const_func __attribute__((overloadable)) popcount(long2 x);
ulong2 const_func __attribute__((overloadable)) popcount(ulong2 x);
long3 const_func __attribute__((overloadable)) popcount(long3 x);
ulong3 const_func __attribute__((overloadable)) popcount(ulong3 x);
long4 const_func __attribute__((overloadable)) popcount(long4 x);
ulong4 const_func __attribute__((overloadable)) popcount(ulong4 x);
long8 const_func __attribute__((overloadable)) popcount(long8 x);
ulong8 const_func __attribute__((overloadable)) popcount(ulong8 x);
long16 const_func __attribute__((overloadable)) popcount(long16 x);
ulong16 const_func __attribute__((overloadable)) popcount(ulong16 x);
/**
* Multiply two 24-bit integer values x and y and add
* the 32-bit integer result to the 32-bit integer z.
* Refer to definition of mul24 to see how the 24-bit
* integer multiplication is performed.
*/
int const_func __attribute__((overloadable)) mad24(int x, int y, int z);
uint const_func __attribute__((overloadable)) mad24(uint x, uint y, uint z);
int2 const_func __attribute__((overloadable)) mad24(int2 x, int2 y, int2 z);
uint2 const_func __attribute__((overloadable)) mad24(uint2 x, uint2 y, uint2 z);
int3 const_func __attribute__((overloadable)) mad24(int3 x, int3 y, int3 z);
uint3 const_func __attribute__((overloadable)) mad24(uint3 x, uint3 y, uint3 z);
int4 const_func __attribute__((overloadable)) mad24(int4 x, int4 y, int4 z);
uint4 const_func __attribute__((overloadable)) mad24(uint4 x, uint4 y, uint4 z);
int8 const_func __attribute__((overloadable)) mad24(int8 x, int8 y, int8 z);
uint8 const_func __attribute__((overloadable)) mad24(uint8 x, uint8 y, uint8 z);
int16 const_func __attribute__((overloadable)) mad24(int16 x, int16 y, int16 z);
uint16 const_func __attribute__((overloadable)) mad24(uint16 x, uint16 y, uint16 z);
/**
* Multiply two 24-bit integer values x and y. x and y
* are 32-bit integers but only the low 24-bits are used
* to perform the multiplication. mul24 should only
* be used when values in x and y are in the range [-
* 2^23, 2^23-1] if x and y are signed integers and in the
* range [0, 2^24-1] if x and y are unsigned integers. If
* x and y are not in this range, the multiplication
* result is implementation-defined.
*/
int const_func __attribute__((overloadable)) mul24(int x, int y);
uint const_func __attribute__((overloadable)) mul24(uint x, uint y);
int2 const_func __attribute__((overloadable)) mul24(int2 x, int2 y);
uint2 const_func __attribute__((overloadable)) mul24(uint2 x, uint2 y);
int3 const_func __attribute__((overloadable)) mul24(int3 x, int3 y);
uint3 const_func __attribute__((overloadable)) mul24(uint3 x, uint3 y);
int4 const_func __attribute__((overloadable)) mul24(int4 x, int4 y);
uint4 const_func __attribute__((overloadable)) mul24(uint4 x, uint4 y);
int8 const_func __attribute__((overloadable)) mul24(int8 x, int8 y);
uint8 const_func __attribute__((overloadable)) mul24(uint8 x, uint8 y);
int16 const_func __attribute__((overloadable)) mul24(int16 x, int16 y);
uint16 const_func __attribute__((overloadable)) mul24(uint16 x, uint16 y);
// Common functions:
/**
* Returns fmin(fmax(x, minval), maxval).
* Results are undefined if minval > maxval.
*/
float const_func __attribute__((overloadable)) clamp(float x, float minval, float maxval);
float2 const_func __attribute__((overloadable)) clamp(float2 x, float2 minval, float2 maxval);
float3 const_func __attribute__((overloadable)) clamp(float3 x, float3 minval, float3 maxval);
float4 const_func __attribute__((overloadable)) clamp(float4 x, float4 minval, float4 maxval);
float8 const_func __attribute__((overloadable)) clamp(float8 x, float8 minval, float8 maxval);
float16 const_func __attribute__((overloadable)) clamp(float16 x, float16 minval, float16 maxval);
float2 const_func __attribute__((overloadable)) clamp(float2 x, float minval, float maxval);
float3 const_func __attribute__((overloadable)) clamp(float3 x, float minval, float maxval);
float4 const_func __attribute__((overloadable)) clamp(float4 x, float minval, float maxval);
float8 const_func __attribute__((overloadable)) clamp(float8 x, float minval, float maxval);
float16 const_func __attribute__((overloadable)) clamp(float16 x, float minval, float maxval);
double const_func __attribute__((overloadable)) clamp(double x, double minval, double maxval);
double2 const_func __attribute__((overloadable)) clamp(double2 x, double2 minval, double2 maxval);
double3 const_func __attribute__((overloadable)) clamp(double3 x, double3 minval, double3 maxval);
double4 const_func __attribute__((overloadable)) clamp(double4 x, double4 minval, double4 maxval);
double8 const_func __attribute__((overloadable)) clamp(double8 x, double8 minval, double8 maxval);
double16 const_func __attribute__((overloadable)) clamp(double16 x, double16 minval, double16 maxval);
double2 const_func __attribute__((overloadable)) clamp(double2 x, double minval, double maxval);
double3 const_func __attribute__((overloadable)) clamp(double3 x, double minval, double maxval);
double4 const_func __attribute__((overloadable)) clamp(double4 x, double minval, double maxval);
double8 const_func __attribute__((overloadable)) clamp(double8 x, double minval, double maxval);
double16 const_func __attribute__((overloadable)) clamp(double16 x, double minval, double maxval);
//half const_func __attribute__((overloadable)) clamp(half x, half minval, half maxval);
//half2 const_func __attribute__((overloadable)) clamp(half2 x, half2 minval, half2 maxval);
//half3 const_func __attribute__((overloadable)) clamp(half3 x, half3 minval, half3 maxval);
//half4 const_func __attribute__((overloadable)) clamp(half4 x, half4 minval, half4 maxval);
//half8 const_func __attribute__((overloadable)) clamp(half8 x, half8 minval, half8 maxval);
//half16 const_func __attribute__((overloadable)) clamp(half16 x, half16 minval, half16 maxval);
//half2 const_func __attribute__((overloadable)) clamp(half2 x, half minval, half maxval);
//half3 const_func __attribute__((overloadable)) clamp(half3 x, half minval, half maxval);
//half4 const_func __attribute__((overloadable)) clamp(half4 x, half minval, half maxval);
//half8 const_func __attribute__((overloadable)) clamp(half8 x, half minval, half maxval);
//half16 const_func __attribute__((overloadable)) clamp(half16 x, half minval, half maxval);
/**
* Converts radians to degrees, i.e. (180 / PI) *
* radians.
*/
float const_func __attribute__((overloadable)) degrees(float radians);
float2 const_func __attribute__((overloadable)) degrees(float2 radians);
float3 const_func __attribute__((overloadable)) degrees(float3 radians);
float4 const_func __attribute__((overloadable)) degrees(float4 radians);
float8 const_func __attribute__((overloadable)) degrees(float8 radians);
float16 const_func __attribute__((overloadable)) degrees(float16 radians);
double const_func __attribute__((overloadable)) degrees(double radians);
double2 const_func __attribute__((overloadable)) degrees(double2 radians);
double3 const_func __attribute__((overloadable)) degrees(double3 radians);
double4 const_func __attribute__((overloadable)) degrees(double4 radians);
double8 const_func __attribute__((overloadable)) degrees(double8 radians);
double16 const_func __attribute__((overloadable)) degrees(double16 radians);
//half const_func __attribute__((overloadable)) degrees(half radians);
//half2 const_func __attribute__((overloadable)) degrees(half2 radians);
//half3 const_func __attribute__((overloadable)) degrees(half3 radians);
//half4 const_func __attribute__((overloadable)) degrees(half4 radians);
//half8 const_func __attribute__((overloadable)) degrees(half8 radians);
//half16 const_func __attribute__((overloadable)) degrees(half16 radians);