diff --git a/projects/hip/CMakeLists.txt b/projects/hip/CMakeLists.txt index 537764548f..a4da3b1920 100644 --- a/projects/hip/CMakeLists.txt +++ b/projects/hip/CMakeLists.txt @@ -193,9 +193,7 @@ if(HIP_PLATFORM STREQUAL "hcc") src/program_state.cpp) set(SOURCE_FILES_DEVICE - src/device_util.cpp - src/hip_ldg.cpp - src/device_functions.cpp) + src/device_util.cpp) execute_process(COMMAND ${HCC_HOME}/bin/hcc-config --ldflags OUTPUT_VARIABLE HCC_LD_FLAGS) set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${HCC_LD_FLAGS} -Wl,-Bsymbolic") @@ -238,7 +236,6 @@ endif() # Install hip_hcc if platform is hcc if(HIP_PLATFORM STREQUAL "hcc") install(TARGETS hip_hcc_static hip_hcc hip_device DESTINATION lib) - install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/hip_hc.ll DESTINATION lib) # Install .hipInfo install(FILES ${PROJECT_BINARY_DIR}/.hipInfo DESTINATION lib) diff --git a/projects/hip/bin/hipcc b/projects/hip/bin/hipcc index 0abf09ed71..d2614297c3 100755 --- a/projects/hip/bin/hipcc +++ b/projects/hip/bin/hipcc @@ -259,8 +259,7 @@ if($HIP_PLATFORM eq "hcc"){ } if(($HIP_PLATFORM eq "hcc")){ - $ENV{HCC_EXTRA_LIBRARIES}="$HIP_PATH/lib/hip_hc.ll\n"; - $ENV{HIP_HC_IR_FILE}=""; + $ENV{HCC_EXTRA_LIBRARIES}="\n"; } if($HIP_PLATFORM eq "nvcc"){ @@ -533,7 +532,7 @@ if($HIP_PLATFORM eq "hcc" or $HIP_PLATFORM eq "clang"){ print "No valid AMD GPU target was either specified or found. Please specify a valid target using --amdgpu-target=" and die(); } - $ENV{HCC_EXTRA_LIBRARIES}="$HIP_PATH/lib/hip_hc.ll\n"; + $ENV{HCC_EXTRA_LIBRARIES}="\n"; if($HIP_PLATFORM eq "hcc") { $GPU_ARCH_OPT = " --amdgpu-target="; diff --git a/projects/hip/include/hip/hcc_detail/device_functions.h b/projects/hip/include/hip/hcc_detail/device_functions.h index ae1b96c979..fb453d02e9 100644 --- a/projects/hip/include/hip/hcc_detail/device_functions.h +++ b/projects/hip/include/hip/hcc_detail/device_functions.h @@ -24,46 +24,171 @@ THE SOFTWARE. #define HIP_INCLUDE_HIP_HCC_DETAIL_DEVICE_FUNCTIONS_H #include "host_defines.h" +#include "math_fwd.h" +#include #include +#include +#include -extern "C" __device__ unsigned int __hip_hc_ir_umul24_int(unsigned int, unsigned int); -extern "C" __device__ signed int __hip_hc_ir_mul24_int(signed int, signed int); -extern "C" __device__ signed int __hip_hc_ir_mulhi_int(signed int, signed int); -extern "C" __device__ unsigned int __hip_hc_ir_umulhi_int(unsigned int, unsigned int); -extern "C" __device__ unsigned int __hip_hc_ir_usad_int(unsigned int, unsigned int, unsigned int); +typedef unsigned long ulong; +typedef unsigned int uint; + +/* +Integer Intrinsics +*/ // integer intrinsic function __poc __clz __ffs __brev -__device__ unsigned int __brev(unsigned int x); -__device__ unsigned long long int __brevll(unsigned long long int x); -__device__ unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s); -__device__ unsigned int __clz(int x); -__device__ unsigned int __clzll(long long int x); -__device__ unsigned int __ffs(int x); -__device__ unsigned int __ffsll(long long int x); +__device__ static inline unsigned int __popc(unsigned int input) { + return __builtin_popcount(input); +} +__device__ static inline unsigned int __popcll(unsigned long long int input) { + return __builtin_popcountl(input); +} + +__device__ static inline unsigned int __clz(unsigned int input) { +#ifdef NVCC_COMPAT + return input == 0 ? 32 : __builtin_clz(input); +#else + return input == 0 ? -1 : __builtin_clz(input); +#endif +} + +__device__ static inline unsigned int __clzll(unsigned long long int input) { +#ifdef NVCC_COMPAT + return input == 0 ? 64 : ( input == 0 ? -1 : __builtin_clzl(input) ); +#else + return input == 0 ? -1 : __builtin_clzl(input); +#endif +} + +__device__ static inline unsigned int __clz(int input) { +#ifdef NVCC_COMPAT + return input == 0 ? 32 : ( input > 0 ? __builtin_clz(input) : __builtin_clz(~input) ); +#else + if (input == 0) return -1; + return input > 0 ? __builtin_clz(input) : __builtin_clz(~input); +#endif +} + +__device__ static inline unsigned int __clzll(long long int input) { +#ifdef NVCC_COMPAT + return input == 0 ? 64 : input > 0 ? __builtin_clzl(input) : __builtin_clzl(~input); +#else + if (input == 0) return -1; + return input > 0 ? __builtin_clzl(input) : __builtin_clzl(~input); +#endif +} + +__device__ static inline unsigned int __ffs(unsigned int input) { +#ifdef NVCC_COMPAT + return ( input == 0 ? -1 : __builtin_ctz(input) ) + 1; +#else + return input == 0 ? -1 : __builtin_ctz(input); +#endif +} + +__device__ static inline unsigned int __ffsll(unsigned long long int input) { +#ifdef NVCC_COMPAT + return ( input == 0 ? -1 : __builtin_ctzl(input) ) + 1; +#else + return input == 0 ? -1 : __builtin_ctzl(input); +#endif +} + +__device__ static inline unsigned int __ffs(int input) { +#ifdef NVCC_COMPAT + return ( input == 0 ? -1 : __builtin_ctz(input) ) + 1; +#else + return input == 0 ? -1 : __builtin_ctz(input); +#endif +} + +__device__ static inline unsigned int __ffsll(long long int input) { +#ifdef NVCC_COMPAT + return ( input == 0 ? -1 : __builtin_ctzl(input) ) + 1; +#else + return input == 0 ? -1 : __builtin_ctzl(input); +#endif +} + +__device__ static inline unsigned int __brev(unsigned int input) { return __llvm_bitrev_b32(input); } + +__device__ static inline unsigned long long int __brevll(unsigned long long int input) { + return __llvm_bitrev_b64(input); +} + +__device__ static unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s); __device__ static unsigned int __hadd(int x, int y); __device__ static int __mul24(int x, int y); -__device__ long long int __mul64hi(long long int x, long long int y); +__device__ static long long int __mul64hi(long long int x, long long int y); __device__ static int __mulhi(int x, int y); -__device__ unsigned int __popc(unsigned int x); -__device__ unsigned int __popcll(unsigned long long int x); __device__ static int __rhadd(int x, int y); __device__ static unsigned int __sad(int x, int y, int z); __device__ static unsigned int __uhadd(unsigned int x, unsigned int y); __device__ static int __umul24(unsigned int x, unsigned int y); -__device__ unsigned long long int __umul64hi(unsigned long long int x, unsigned long long int y); +__device__ static unsigned long long int __umul64hi(unsigned long long int x, unsigned long long int y); __device__ static unsigned int __umulhi(unsigned int x, unsigned int y); __device__ static unsigned int __urhadd(unsigned int x, unsigned int y); __device__ static unsigned int __usad(unsigned int x, unsigned int y, unsigned int z); +struct ucharHolder { + union { + unsigned char c[4]; + unsigned int ui; + }; +} __attribute__((aligned(4))); + +struct uchar2Holder { + union { + unsigned int ui[2]; + unsigned char c[8]; + }; +} __attribute__((aligned(8))); + +__device__ +static inline unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s) { + struct uchar2Holder cHoldVal; + struct ucharHolder cHoldKey; + struct ucharHolder cHoldOut; + cHoldKey.ui = s; + cHoldVal.ui[0] = x; + cHoldVal.ui[1] = y; + cHoldOut.c[0] = cHoldVal.c[cHoldKey.c[0]]; + cHoldOut.c[1] = cHoldVal.c[cHoldKey.c[1]]; + cHoldOut.c[2] = cHoldVal.c[cHoldKey.c[2]]; + cHoldOut.c[3] = cHoldVal.c[cHoldKey.c[3]]; + return cHoldOut.ui; +} + __device__ static inline unsigned int __hadd(int x, int y) { int z = x + y; int sign = z & 0x8000000; int value = z & 0x7FFFFFFF; return ((value) >> 1 || sign); } -__device__ static inline int __mul24(int x, int y) { return __hip_hc_ir_mul24_int(x, y); } -__device__ static inline int __mulhi(int x, int y) { return __hip_hc_ir_mulhi_int(x, y); } + +__device__ static inline int __mul24(int x, int y) { + return __ockl_mul24_i32(x, y); +} + +__device__ static inline long long __mul64hi(long long int x, long long int y) { + ulong x0 = (ulong)x & 0xffffffffUL; + long x1 = x >> 32; + ulong y0 = (ulong)y & 0xffffffffUL; + long y1 = y >> 32; + ulong z0 = x0*y0; + long t = x1*y0 + (z0 >> 32); + long z1 = t & 0xffffffffL; + long z2 = t >> 32; + z1 = x0*y1 + z1; + return x1*y1 + z2 + (z1 >> 32); +} + +__device__ static inline int __mulhi(int x, int y) { + return __ockl_mul_hi_i32(x, y); +} + __device__ static inline int __rhadd(int x, int y) { int z = x + y + 1; int sign = z & 0x8000000; @@ -77,57 +202,307 @@ __device__ static inline unsigned int __uhadd(unsigned int x, unsigned int y) { return (x + y) >> 1; } __device__ static inline int __umul24(unsigned int x, unsigned int y) { - return __hip_hc_ir_umul24_int(x, y); + return __ockl_mul24_u32(x, y); } + +__device__ +static inline unsigned long long __umul64hi(unsigned long long int x, unsigned long long int y) { + ulong x0 = x & 0xffffffffUL; + ulong x1 = x >> 32; + ulong y0 = y & 0xffffffffUL; + ulong y1 = y >> 32; + ulong z0 = x0*y0; + ulong t = x1*y0 + (z0 >> 32); + ulong z1 = t & 0xffffffffUL; + ulong z2 = t >> 32; + z1 = x0*y1 + z1; + return x1*y1 + z2 + (z1 >> 32); +} + __device__ static inline unsigned int __umulhi(unsigned int x, unsigned int y) { - return __hip_hc_ir_umulhi_int(x, y); + return __ockl_mul_hi_u32(x, y); } __device__ static inline unsigned int __urhadd(unsigned int x, unsigned int y) { return (x + y + 1) >> 1; } __device__ static inline unsigned int __usad(unsigned int x, unsigned int y, unsigned int z) { - return __hip_hc_ir_usad_int(x, y, z); + return __ockl_sad_u32(x, y, z); } -extern __device__ __attribute__((const)) unsigned int __mbcnt_lo(unsigned int x, unsigned int y) __asm("llvm.amdgcn.mbcnt.lo"); -extern __device__ __attribute__((const)) unsigned int __mbcnt_hi(unsigned int x, unsigned int y) __asm("llvm.amdgcn.mbcnt.hi"); - __device__ static inline unsigned int __lane_id() { return __mbcnt_hi(-1, __mbcnt_lo(-1, 0)); } /* -Rounding modes are not yet supported in HIP +HIP specific device functions */ -__device__ float __double2float_rd(double x); -__device__ float __double2float_rn(double x); -__device__ float __double2float_ru(double x); -__device__ float __double2float_rz(double x); +// utility union type +union __u { + int i; + unsigned int u; + float f; +}; -__device__ int __double2hiint(double x); +__device__ static inline unsigned __hip_ds_bpermute(int index, unsigned src) { + __u tmp; tmp.u = src; + tmp.i = __llvm_amdgcn_ds_bpermute(index, tmp.i); + return tmp.u; +} -__device__ int __double2int_rd(double x); -__device__ int __double2int_rn(double x); -__device__ int __double2int_ru(double x); -__device__ int __double2int_rz(double x); +__device__ static inline float __hip_ds_bpermutef(int index, float src) { + __u tmp; tmp.f = src; + tmp.i = __llvm_amdgcn_ds_bpermute(index, tmp.i); + return tmp.f; +} -__device__ long long int __double2ll_rd(double x); -__device__ long long int __double2ll_rn(double x); -__device__ long long int __double2ll_ru(double x); -__device__ long long int __double2ll_rz(double x); +__device__ static inline unsigned __hip_ds_permute(int index, unsigned src) { + __u tmp; tmp.u = src; + tmp.i = __llvm_amdgcn_ds_permute(index, tmp.i); + return tmp.u; +} -__device__ int __double2loint(double x); +__device__ static inline float __hip_ds_permutef(int index, float src) { + __u tmp; tmp.u = src; + tmp.i = __llvm_amdgcn_ds_permute(index, tmp.i); + return tmp.u; +} -__device__ unsigned int __double2uint_rd(double x); -__device__ unsigned int __double2uint_rn(double x); -__device__ unsigned int __double2uint_ru(double x); -__device__ unsigned int __double2uint_rz(double x); +__device__ static inline unsigned __hip_ds_swizzle(unsigned int src, int pattern) { + __u tmp; tmp.u = src; + tmp.i = __llvm_amdgcn_ds_swizzle(tmp.i, pattern); + return tmp.u; +} +__device__ static inline float __hip_ds_swizzlef(float src, int pattern) { + __u tmp; tmp.f = src; + tmp.i = __llvm_amdgcn_ds_swizzle(tmp.i, pattern); + return tmp.f; +} -__device__ unsigned long long int __double2ull_rd(double x); -__device__ unsigned long long int __double2ull_rn(double x); -__device__ unsigned long long int __double2ull_ru(double x); -__device__ unsigned long long int __double2ull_rz(double x); +__device__ static inline int __hip_move_dpp(int src, int dpp_ctrl, int row_mask, + int bank_mask, bool bound_ctrl) { + return __llvm_amdgcn_move_dpp(src, dpp_ctrl, row_mask, bank_mask, bound_ctrl); +} + +static constexpr int warpSize = 64; + + __device__ +inline +int __shfl(int var, int src_lane, int width = warpSize) { + int self = __lane_id(); + int index = src_lane + (self & ~(width-1)); + return __llvm_amdgcn_ds_bpermute(index<<2, var); +} +__device__ +inline +unsigned int __shfl(unsigned int var, int src_lane, int width = warpSize) { + __u tmp; tmp.u = var; + tmp.i = __shfl(tmp.i, src_lane, width); + return tmp.u; +} +__device__ +inline +float __shfl(float var, int src_lane, int width = warpSize) { + __u tmp; tmp.f = var; + tmp.i = __shfl(tmp.i, src_lane, width); + return tmp.f; +} +__device__ +inline +double __shfl(double var, int src_lane, int width = warpSize) { + __u tmp; tmp.f = (float) var; + tmp.i = __shfl(tmp.i, src_lane, width); + return (double) tmp.f; +} + + __device__ +inline +int __shfl_up(int var, unsigned int lane_delta, int width = warpSize) { + int self = __lane_id(); + int index = self - lane_delta; + index = (index < (self & ~(width-1)))?self:index; + return __llvm_amdgcn_ds_bpermute(index<<2, var); +} +__device__ +inline +unsigned int __shfl_up(unsigned int var, unsigned int lane_delta, int width = warpSize) { + __u tmp; tmp.u = var; + tmp.i = __shfl_up(tmp.i, lane_delta, width); + return tmp.u; +} +__device__ +inline +float __shfl_up(float var, unsigned int lane_delta, int width = warpSize) { + __u tmp; tmp.f = var; + tmp.i = __shfl_up(tmp.i, lane_delta, width); + return tmp.f; +} +__device__ +inline +double __shfl_up(double var, unsigned int lane_delta, int width = warpSize) { + __u tmp; tmp.f = (float) var; + tmp.i = __shfl_up(tmp.i, lane_delta, width); + return (double) tmp.f; +} + +__device__ +inline +int __shfl_down(int var, unsigned int lane_delta, int width = warpSize) { + int self = __lane_id(); + int index = self + lane_delta; + index = (int)((self&(width-1))+lane_delta) >= width?self:index; + return __llvm_amdgcn_ds_bpermute(index<<2, var); +} +__device__ +inline +unsigned int __shfl_down(unsigned int var, unsigned int lane_delta, int width = warpSize) { + __u tmp; tmp.u = var; + tmp.i = __shfl_down(tmp.i, lane_delta, width); + return tmp.u; +} +__device__ +inline +float __shfl_down(float var, unsigned int lane_delta, int width = warpSize) { + __u tmp; tmp.f = var; + tmp.i = __shfl_down(tmp.i, lane_delta, width); + return tmp.f; +} +__device__ +inline +double __shfl_down(double var, unsigned int lane_delta, int width = warpSize) { + __u tmp; tmp.f = (float) var; + tmp.i = __shfl_down(tmp.i, lane_delta, width); + return (double) tmp.f; +} + +__device__ +inline +int __shfl_xor(int var, int lane_mask, int width = warpSize) { + int self = __lane_id(); + int index = self^lane_mask; + index = index >= ((self+width)&~(width-1))?self:index; + return __llvm_amdgcn_ds_bpermute(index<<2, var); +} +__device__ +inline +unsigned int __shfl_xor(unsigned int var, int lane_mask, int width = warpSize) { + __u tmp; tmp.u = var; + tmp.i = __shfl_xor(tmp.i, lane_mask, width); + return tmp.u; +} +__device__ +inline +float __shfl_xor(float var, int lane_mask, int width = warpSize) { + __u tmp; tmp.f = var; + tmp.i = __shfl_xor(tmp.i, lane_mask, width); + return tmp.f; +} +__device__ +inline +double __shfl_xor(double var, int lane_mask, int width = warpSize) { + __u tmp; tmp.f = (float) var; + tmp.i = __shfl_xor(tmp.i, lane_mask, width); + return (double) tmp.f; +} + +#define MASK1 0x00ff00ff +#define MASK2 0xff00ff00 + +__device__ static inline char4 __hip_hc_add8pk(char4 in1, char4 in2) { + char4 out; + unsigned one1 = in1.w & MASK1; + unsigned one2 = in2.w & MASK1; + out.w = (one1 + one2) & MASK1; + one1 = in1.w & MASK2; + one2 = in2.w & MASK2; + out.w = out.w | ((one1 + one2) & MASK2); + return out; +} + +__device__ static inline char4 __hip_hc_sub8pk(char4 in1, char4 in2) { + char4 out; + unsigned one1 = in1.w & MASK1; + unsigned one2 = in2.w & MASK1; + out.w = (one1 - one2) & MASK1; + one1 = in1.w & MASK2; + one2 = in2.w & MASK2; + out.w = out.w | ((one1 - one2) & MASK2); + return out; +} + +__device__ static inline char4 __hip_hc_mul8pk(char4 in1, char4 in2) { + char4 out; + unsigned one1 = in1.w & MASK1; + unsigned one2 = in2.w & MASK1; + out.w = (one1 * one2) & MASK1; + one1 = in1.w & MASK2; + one2 = in2.w & MASK2; + out.w = out.w | ((one1 * one2) & MASK2); + return out; +} + +/* + * Rounding modes are not yet supported in HIP + * TODO: Conversion functions are not correct, need to fix when BE is ready +*/ + +__device__ static inline float __double2float_rd(double x) { return (double)x; } +__device__ static inline float __double2float_rn(double x) { return (double)x; } +__device__ static inline float __double2float_ru(double x) { return (double)x; } +__device__ static inline float __double2float_rz(double x) { return (double)x; } + +__device__ static inline int __double2hiint(double x) { + static_assert(sizeof(double) == 2 * sizeof(int), ""); + + int tmp[2]; + __builtin_memcpy(tmp, &x, sizeof(tmp)); + + return tmp[1]; +} +__device__ static inline int __double2loint(double x) { + static_assert(sizeof(double) == 2 * sizeof(int), ""); + + int tmp[2]; + __builtin_memcpy(tmp, &x, sizeof(tmp)); + + return tmp[0]; +} + +__device__ static inline int __double2int_rd(double x) { return (int)x; } +__device__ static inline int __double2int_rn(double x) { return (int)x; } +__device__ static inline int __double2int_ru(double x) { return (int)x; } +__device__ static inline int __double2int_rz(double x) { return (int)x; } + +__device__ static inline long long int __double2ll_rd(double x) { return (long long int)x; } +__device__ static inline long long int __double2ll_rn(double x) { return (long long int)x; } +__device__ static inline long long int __double2ll_ru(double x) { return (long long int)x; } +__device__ static inline long long int __double2ll_rz(double x) { return (long long int)x; } + +__device__ static inline unsigned int __double2uint_rd(double x) { return (unsigned int)x; } +__device__ static inline unsigned int __double2uint_rn(double x) { return (unsigned int)x; } +__device__ static inline unsigned int __double2uint_ru(double x) { return (unsigned int)x; } +__device__ static inline unsigned int __double2uint_rz(double x) { return (unsigned int)x; } + +__device__ static inline unsigned long long int __double2ull_rd(double x) { + return (unsigned long long int)x; +} +__device__ static inline unsigned long long int __double2ull_rn(double x) { + return (unsigned long long int)x; +} +__device__ static inline unsigned long long int __double2ull_ru(double x) { + return (unsigned long long int)x; +} +__device__ static inline unsigned long long int __double2ull_rz(double x) { + return (unsigned long long int)x; +} + +__device__ static inline long long int __double_as_longlong(double x) { + static_assert(sizeof(long long) == sizeof(double), ""); + + long long tmp; + __builtin_memcpy(&tmp, &x, sizeof(tmp)); + + return tmp; +} -__device__ long long int __double_as_longlong(double x); /* __device__ unsigned short __float2half_rn(float x); __device__ float __half2float(unsigned short); @@ -142,72 +517,457 @@ CUDA implements half as unsigned short whereas, HIP doesn't. */ -__device__ int __float2int_rd(float x); -__device__ int __float2int_rn(float x); -__device__ int __float2int_ru(float x); -__device__ int __float2int_rz(float x); +__device__ static inline int __float2int_rd(float x) { return (int)__ocml_floor_f32(x); } +__device__ static inline int __float2int_rn(float x) { return (int)__ocml_rint_f32(x); } +__device__ static inline int __float2int_ru(float x) { return (int)__ocml_ceil_f32(x); } +__device__ static inline int __float2int_rz(float x) { return (int)__ocml_trunc_f32(x); } -__device__ long long int __float2ll_rd(float x); -__device__ long long int __float2ll_rn(float x); -__device__ long long int __float2ll_ru(float x); -__device__ long long int __float2ll_rz(float x); +__device__ static inline long long int __float2ll_rd(float x) { return (long long int)x; } +__device__ static inline long long int __float2ll_rn(float x) { return (long long int)x; } +__device__ static inline long long int __float2ll_ru(float x) { return (long long int)x; } +__device__ static inline long long int __float2ll_rz(float x) { return (long long int)x; } -__device__ unsigned int __float2uint_rd(float x); -__device__ unsigned int __float2uint_rn(float x); -__device__ unsigned int __float2uint_ru(float x); -__device__ unsigned int __float2uint_rz(float x); +__device__ static inline unsigned int __float2uint_rd(float x) { return (unsigned int)x; } +__device__ static inline unsigned int __float2uint_rn(float x) { return (unsigned int)x; } +__device__ static inline unsigned int __float2uint_ru(float x) { return (unsigned int)x; } +__device__ static inline unsigned int __float2uint_rz(float x) { return (unsigned int)x; } -__device__ unsigned long long int __float2ull_rd(float x); -__device__ unsigned long long int __float2ull_rn(float x); -__device__ unsigned long long int __float2ull_ru(float x); -__device__ unsigned long long int __float2ull_rz(float x); +__device__ static inline unsigned long long int __float2ull_rd(float x) { + return (unsigned long long int)x; +} +__device__ static inline unsigned long long int __float2ull_rn(float x) { + return (unsigned long long int)x; +} +__device__ static inline unsigned long long int __float2ull_ru(float x) { + return (unsigned long long int)x; +} +__device__ static inline unsigned long long int __float2ull_rz(float x) { + return (unsigned long long int)x; +} -__device__ int __float_as_int(float x); -__device__ unsigned int __float_as_uint(float x); -__device__ double __hiloint2double(int hi, int lo); -__device__ double __int2double_rn(int x); +__device__ static inline int __float_as_int(float x) { + static_assert(sizeof(int) == sizeof(float), ""); -__device__ float __int2float_rd(int x); -__device__ float __int2float_rn(int x); -__device__ float __int2float_ru(int x); -__device__ float __int2float_rz(int x); + int tmp; + __builtin_memcpy(&tmp, &x, sizeof(tmp)); -__device__ float __int_as_float(int x); + return tmp; +} -__device__ double __ll2double_rd(long long int x); -__device__ double __ll2double_rn(long long int x); -__device__ double __ll2double_ru(long long int x); -__device__ double __ll2double_rz(long long int x); +__device__ static inline unsigned int __float_as_uint(float x) { + static_assert(sizeof(unsigned int) == sizeof(float), ""); -__device__ float __ll2float_rd(long long int x); -__device__ float __ll2float_rn(long long int x); -__device__ float __ll2float_ru(long long int x); -__device__ float __ll2float_rz(long long int x); + unsigned int tmp; + __builtin_memcpy(&tmp, &x, sizeof(tmp)); -__device__ double __longlong_as_double(long long int x); + return tmp; +} -__device__ double __uint2double_rn(int x); +__device__ static inline double __hiloint2double(int hi, int lo) { + static_assert(sizeof(double) == sizeof(uint64_t), ""); -__device__ float __uint2float_rd(unsigned int x); -__device__ float __uint2float_rn(unsigned int x); -__device__ float __uint2float_ru(unsigned int x); -__device__ float __uint2float_rz(unsigned int x); + uint64_t tmp0 = (static_cast(hi) << 32ull) | static_cast(lo); + double tmp1; + __builtin_memcpy(&tmp1, &tmp0, sizeof(tmp0)); -__device__ float __uint_as_float(unsigned int x); + return tmp1; +} -__device__ double __ull2double_rd(unsigned long long int x); -__device__ double __ull2double_rn(unsigned long long int x); -__device__ double __ull2double_ru(unsigned long long int x); -__device__ double __ull2double_rz(unsigned long long int x); +__device__ static inline double __int2double_rn(int x) { return (double)x; } -__device__ float __ull2float_rd(unsigned long long int x); -__device__ float __ull2float_rn(unsigned long long int x); -__device__ float __ull2float_ru(unsigned long long int x); -__device__ float __ull2float_rz(unsigned long long int x); +__device__ static inline float __int2float_rd(int x) { return (float)x; } +__device__ static inline float __int2float_rn(int x) { return (float)x; } +__device__ static inline float __int2float_ru(int x) { return (float)x; } +__device__ static inline float __int2float_rz(int x) { return (float)x; } -__device__ char4 __hip_hc_add8pk(char4, char4); -__device__ char4 __hip_hc_sub8pk(char4, char4); -__device__ char4 __hip_hc_mul8pk(char4, char4); +__device__ static inline float __int_as_float(int x) { + static_assert(sizeof(float) == sizeof(int), ""); + + float tmp; + __builtin_memcpy(&tmp, &x, sizeof(tmp)); + + return tmp; +} + +__device__ static inline double __ll2double_rd(long long int x) { return (double)x; } +__device__ static inline double __ll2double_rn(long long int x) { return (double)x; } +__device__ static inline double __ll2double_ru(long long int x) { return (double)x; } +__device__ static inline double __ll2double_rz(long long int x) { return (double)x; } + +__device__ static inline float __ll2float_rd(long long int x) { return (float)x; } +__device__ static inline float __ll2float_rn(long long int x) { return (float)x; } +__device__ static inline float __ll2float_ru(long long int x) { return (float)x; } +__device__ static inline float __ll2float_rz(long long int x) { return (float)x; } + +__device__ static inline double __longlong_as_double(long long int x) { + static_assert(sizeof(double) == sizeof(long long), ""); + + double tmp; + __builtin_memcpy(&tmp, &x, sizeof(tmp)); + + return x; +} + +__device__ static inline double __uint2double_rn(int x) { return (double)x; } + +__device__ static inline float __uint2float_rd(unsigned int x) { return (float)x; } +__device__ static inline float __uint2float_rn(unsigned int x) { return (float)x; } +__device__ static inline float __uint2float_ru(unsigned int x) { return (float)x; } +__device__ static inline float __uint2float_rz(unsigned int x) { return (float)x; } + +__device__ static inline float __uint_as_float(unsigned int x) { + static_assert(sizeof(float) == sizeof(unsigned int), ""); + + float tmp; + __builtin_memcpy(&tmp, &x, sizeof(tmp)); + + return tmp; +} + +__device__ static inline double __ull2double_rd(unsigned long long int x) { return (double)x; } +__device__ static inline double __ull2double_rn(unsigned long long int x) { return (double)x; } +__device__ static inline double __ull2double_ru(unsigned long long int x) { return (double)x; } +__device__ static inline double __ull2double_rz(unsigned long long int x) { return (double)x; } + +__device__ static inline float __ull2float_rd(unsigned long long int x) { return (float)x; } +__device__ static inline float __ull2float_rn(unsigned long long int x) { return (float)x; } +__device__ static inline float __ull2float_ru(unsigned long long int x) { return (float)x; } +__device__ static inline float __ull2float_rz(unsigned long long int x) { return (float)x; } + +#if defined(__HCC__) +#define __HCC_OR_HIP_CLANG__ 1 +#elif defined(__clang__) && defined(__HIP__) +#define __HCC_OR_HIP_CLANG__ 1 +#else +#define __HCC_OR_HIP_CLANG__ 0 +#endif + +#ifdef __HCC_OR_HIP_CLANG__ + +#ifdef __HIP_DEVICE_COMPILE__ + +// Clock functions +__device__ +inline +long long int __clock64() { return (long long int) __builtin_amdgcn_s_memrealtime(); } + +__device__ +inline +long long int __clock() { return (long long int) __builtin_amdgcn_s_memrealtime(); } + +// hip.amdgcn.bc - named sync +__device__ +inline +void __named_sync(int a, int b) { __builtin_amdgcn_s_barrier(); } + +#endif // __HIP_DEVICE_COMPILE__ + +// warp vote function __all __any __ballot +__device__ +inline +int __all(int predicate) { + return __ockl_wfall_i32(predicate); +} + +__device__ +inline +int __any(int predicate) { +#ifdef NVCC_COMPAT + if (__ockl_wfany_i32(predicate) != 0) + return 1; + else + return 0; +#else + return __ockl_wfany_i32(predicate); +#endif +} + +// XXX from llvm/include/llvm/IR/InstrTypes.h +#define ICMP_NE 33 + +__device__ +inline +unsigned long long int __ballot(int predicate) { + return __llvm_amdgcn_icmp_i32(predicate, 0, ICMP_NE); +} + +__device__ +inline +unsigned long long int __ballot64(int predicate) { + return __llvm_amdgcn_icmp_i32(predicate, 0, ICMP_NE); +} + +// hip.amdgcn.bc - lanemask +__device__ +inline +int64_t __lanemask_gt() +{ + int32_t activelane = __ockl_activelane_u32(); + int64_t ballot = __ballot64(1); + if (activelane != 63) { + int64_t tmp = (~0UL) << (activelane + 1); + return tmp & ballot; + } + return 0; +} + +__device__ +inline +int64_t __lanemask_lt() +{ + int32_t activelane = __ockl_activelane_u32(); + int64_t ballot = __ballot64(1); + if (activelane == 0) + return 0; + return ballot; +} + +__device__ inline void* __local_to_generic(void* p) { return p; } + +#ifdef __HIP_DEVICE_COMPILE__ +__device__ +inline +void* __get_dynamicgroupbaseptr() +{ + // Get group segment base pointer. + return (char*)__local_to_generic((void*)__to_local(__llvm_amdgcn_groupstaticsize())); +} +#else +__device__ +void* __get_dynamicgroupbaseptr(); +#endif // __HIP_DEVICE_COMPILE__ + +__device__ +inline +void *__amdgcn_get_dynamicgroupbaseptr() { + return __get_dynamicgroupbaseptr(); +} + + + +// hip.amdgcn.bc - sync threads +#define __CLK_LOCAL_MEM_FENCE 0x01 +typedef unsigned __cl_mem_fence_flags; + +typedef enum __memory_scope { + __memory_scope_work_item = __OPENCL_MEMORY_SCOPE_WORK_ITEM, + __memory_scope_work_group = __OPENCL_MEMORY_SCOPE_WORK_GROUP, + __memory_scope_device = __OPENCL_MEMORY_SCOPE_DEVICE, + __memory_scope_all_svm_devices = __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES, + __memory_scope_sub_group = __OPENCL_MEMORY_SCOPE_SUB_GROUP +} __memory_scope; + +// enum values aligned with what clang uses in EmitAtomicExpr() +typedef enum __memory_order +{ + __memory_order_relaxed = __ATOMIC_RELAXED, + __memory_order_acquire = __ATOMIC_ACQUIRE, + __memory_order_release = __ATOMIC_RELEASE, + __memory_order_acq_rel = __ATOMIC_ACQ_REL, + __memory_order_seq_cst = __ATOMIC_SEQ_CST +} __memory_order; + +__device__ +inline +static void +__atomic_work_item_fence(__cl_mem_fence_flags flags, __memory_order order, __memory_scope scope) +{ + // We're tying global-happens-before and local-happens-before together as does HSA + if (order != __memory_order_relaxed) { + switch (scope) { + case __memory_scope_work_item: + break; + case __memory_scope_sub_group: + switch (order) { + case __memory_order_relaxed: break; + case __memory_order_acquire: __llvm_fence_acq_sg(); break; + case __memory_order_release: __llvm_fence_rel_sg(); break; + case __memory_order_acq_rel: __llvm_fence_ar_sg(); break; + case __memory_order_seq_cst: __llvm_fence_sc_sg(); break; + } + break; + case __memory_scope_work_group: + switch (order) { + case __memory_order_relaxed: break; + case __memory_order_acquire: __llvm_fence_acq_wg(); break; + case __memory_order_release: __llvm_fence_rel_wg(); break; + case __memory_order_acq_rel: __llvm_fence_ar_wg(); break; + case __memory_order_seq_cst: __llvm_fence_sc_wg(); break; + } + break; + case __memory_scope_device: + switch (order) { + case __memory_order_relaxed: break; + case __memory_order_acquire: __llvm_fence_acq_dev(); break; + case __memory_order_release: __llvm_fence_rel_dev(); break; + case __memory_order_acq_rel: __llvm_fence_ar_dev(); break; + case __memory_order_seq_cst: __llvm_fence_sc_dev(); break; + } + break; + case __memory_scope_all_svm_devices: + switch (order) { + case __memory_order_relaxed: break; + case __memory_order_acquire: __llvm_fence_acq_sys(); break; + case __memory_order_release: __llvm_fence_rel_sys(); break; + case __memory_order_acq_rel: __llvm_fence_ar_sys(); break; + case __memory_order_seq_cst: __llvm_fence_sc_sys(); break; + } + break; + } + } +} + +// Memory Fence Functions +__device__ +inline +static void __threadfence() +{ + __atomic_work_item_fence(0, __memory_order_seq_cst, __memory_scope_device); +} + +__device__ +inline +static void __threadfence_block() +{ + __atomic_work_item_fence(0, __memory_order_seq_cst, __memory_scope_work_group); +} + +__device__ +inline +static void __threadfence_system() +{ + __atomic_work_item_fence(0, __memory_order_seq_cst, __memory_scope_all_svm_devices); +} + +#endif // __HCC_OR_HIP_CLANG__ + +#ifdef __HCC__ + +/** + * extern __shared__ + */ + +// Macro to replace extern __shared__ declarations +// to local variable definitions +#define HIP_DYNAMIC_SHARED(type, var) type* var = (type*)__get_dynamicgroupbaseptr(); + +#define HIP_DYNAMIC_SHARED_ATTRIBUTE + + +#elif defined(__clang__) && defined(__HIP__) + +#pragma push_macro("__DEVICE__") +#define __DEVICE__ extern "C" __device__ __attribute__((always_inline)) \ + __attribute__((weak)) + +__DEVICE__ +inline +void __assert_fail(const char * __assertion, + const char *__file, + unsigned int __line, + const char *__function) +{ + // Ignore all the args for now. + __builtin_trap(); +} + +__DEVICE__ +inline +void __assertfail(const char * __assertion, + const char *__file, + unsigned int __line, + const char *__function, + size_t charsize) +{ + // ignore all the args for now. + __builtin_trap(); +} + +__device__ +inline +static void __work_group_barrier(__cl_mem_fence_flags flags, __memory_scope scope) +{ + if (flags) { + __atomic_work_item_fence(flags, __memory_order_release, scope); + __builtin_amdgcn_s_barrier(); + __atomic_work_item_fence(flags, __memory_order_acquire, scope); + } else { + __builtin_amdgcn_s_barrier(); + } +} + +__device__ +inline +static void __barrier(int n) +{ + __work_group_barrier((__cl_mem_fence_flags)n, __memory_scope_work_group); +} + +__device__ +inline +__attribute__((noduplicate)) +void __syncthreads() +{ + __barrier(__CLK_LOCAL_MEM_FENCE); +} + +// hip.amdgcn.bc - device routine +/* + HW_ID Register bit structure + WAVE_ID 3:0 Wave buffer slot number. 0-9. + SIMD_ID 5:4 SIMD which the wave is assigned to within the CU. + PIPE_ID 7:6 Pipeline from which the wave was dispatched. + CU_ID 11:8 Compute Unit the wave is assigned to. + SH_ID 12 Shader Array (within an SE) the wave is assigned to. + SE_ID 14:13 Shader Engine the wave is assigned to. + TG_ID 19:16 Thread-group ID + VM_ID 23:20 Virtual Memory ID + QUEUE_ID 26:24 Queue from which this wave was dispatched. + STATE_ID 29:27 State ID (graphics only, not compute). + ME_ID 31:30 Micro-engine ID. + */ + +#define HW_ID 4 + +#define HW_ID_CU_ID_SIZE 4 +#define HW_ID_CU_ID_OFFSET 8 + +#define HW_ID_SE_ID_SIZE 2 +#define HW_ID_SE_ID_OFFSET 13 + +/* + Encoding of parameter bitmask + HW_ID 5:0 HW_ID + OFFSET 10:6 Range: 0..31 + SIZE 15:11 Range: 1..32 + */ + +#define GETREG_IMMED(SZ,OFF,REG) (SZ << 11) | (OFF << 6) | REG + +__device__ +inline +unsigned __smid(void) +{ + unsigned cu_id = __builtin_amdgcn_s_getreg( + GETREG_IMMED(HW_ID_CU_ID_SIZE, HW_ID_CU_ID_OFFSET, HW_ID)); + unsigned se_id = __builtin_amdgcn_s_getreg( + GETREG_IMMED(HW_ID_SE_ID_SIZE, HW_ID_SE_ID_OFFSET, HW_ID)); + + /* Each shader engine has 16 CU */ + return (se_id << HW_ID_CU_ID_SIZE) + cu_id; +} + +#pragma push_macro("__DEVICE__") + +// Macro to replace extern __shared__ declarations +// to local variable definitions +#define HIP_DYNAMIC_SHARED(type, var) \ + type* var = (type*)__amdgcn_get_dynamicgroupbaseptr(); + +#define HIP_DYNAMIC_SHARED_ATTRIBUTE + + +#endif //defined(__clang__) && defined(__HIP__) #endif diff --git a/projects/hip/include/hip/hcc_detail/device_library_decls.h b/projects/hip/include/hip/hcc_detail/device_library_decls.h new file mode 100644 index 0000000000..2a14b0b814 --- /dev/null +++ b/projects/hip/include/hip/hcc_detail/device_library_decls.h @@ -0,0 +1,80 @@ +/* +Copyright (c) 2015 - present Advanced Micro Devices, Inc. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +/** + * @file hcc_detail/device_library_decls.h + * @brief Contains declarations for types and functions in device library. + */ + +#ifndef HIP_INCLUDE_HIP_HCC_DETAIL_DEVICE_LIBRARY_DECLS_H +#define HIP_INCLUDE_HIP_HCC_DETAIL_DEVICE_LIBRARY_DECLS_H + +#include "hip/hcc_detail/host_defines.h" + +extern "C" __device__ __attribute__((const)) bool __ockl_wfany_i32(int); +extern "C" __device__ __attribute__((const)) bool __ockl_wfall_i32(int); +extern "C" __device__ uint __ockl_activelane_u32(void); + +extern "C" __device__ __attribute__((const)) uint __ockl_mul24_u32(uint, uint); +extern "C" __device__ __attribute__((const)) int __ockl_mul24_i32(int, int); +extern "C" __device__ __attribute__((const)) uint __ockl_mul_hi_u32(uint, uint); +extern "C" __device__ __attribute__((const)) int __ockl_mul_hi_i32(int, int); +extern "C" __device__ __attribute__((const)) uint __ockl_sad_u32(uint, uint, uint); + +extern "C" __device__ __attribute__((const)) float __ocml_floor_f32(float); +extern "C" __device__ __attribute__((const)) float __ocml_rint_f32(float); +extern "C" __device__ __attribute__((const)) float __ocml_ceil_f32(float); +extern "C" __device__ __attribute__((const)) float __ocml_trunc_f32(float); + +extern "C" __device__ __attribute__((const)) float __ocml_fmin_f32(float, float); +extern "C" __device__ __attribute__((const)) float __ocml_fmax_f32(float, float); + +// Introduce local address space +#define __local __attribute__((address_space(3))) + +#ifdef __HIP_DEVICE_COMPILE__ +__device__ inline static __local void* __to_local(unsigned x) { return (__local void*)x; } +#endif //__HIP_DEVICE_COMPILE__ + +// __llvm_fence* functions from device-libs/irif/src/fence.ll +extern "C" __device__ void __llvm_fence_acq_sg(void); +extern "C" __device__ void __llvm_fence_acq_wg(void); +extern "C" __device__ void __llvm_fence_acq_dev(void); +extern "C" __device__ void __llvm_fence_acq_sys(void); + +extern "C" __device__ void __llvm_fence_rel_sg(void); +extern "C" __device__ void __llvm_fence_rel_wg(void); +extern "C" __device__ void __llvm_fence_rel_dev(void); +extern "C" __device__ void __llvm_fence_rel_sys(void); + +extern "C" __device__ void __llvm_fence_ar_sg(void); +extern "C" __device__ void __llvm_fence_ar_wg(void); +extern "C" __device__ void __llvm_fence_ar_dev(void); +extern "C" __device__ void __llvm_fence_ar_sys(void); + + +extern "C" __device__ void __llvm_fence_sc_sg(void); +extern "C" __device__ void __llvm_fence_sc_wg(void); +extern "C" __device__ void __llvm_fence_sc_dev(void); +extern "C" __device__ void __llvm_fence_sc_sys(void); + +#endif diff --git a/projects/hip/include/hip/hcc_detail/hip_ldg.h b/projects/hip/include/hip/hcc_detail/hip_ldg.h index 281550cd4c..a5b80b0a1b 100644 --- a/projects/hip/include/hip/hcc_detail/hip_ldg.h +++ b/projects/hip/include/hip/hcc_detail/hip_ldg.h @@ -23,54 +23,81 @@ THE SOFTWARE. #ifndef HIP_INCLUDE_HIP_HCC_DETAIL_HIP_LDG_H #define HIP_INCLUDE_HIP_HCC_DETAIL_HIP_LDG_H -#if defined __HCC__ -#if __hcc_workweek__ >= 16164 +#if defined(__HCC_OR_HIP_CLANG__) +#if __hcc_workweek__ >= 16164 || defined(__HIP_CLANG_ONLY__) #include "hip_vector_types.h" #include "host_defines.h" -__device__ char __ldg(const char*); -__device__ char2 __ldg(const char2*); -__device__ char4 __ldg(const char4*); -__device__ signed char __ldg(const signed char*); -__device__ unsigned char __ldg(const unsigned char*); +__device__ inline static char __ldg(const char* ptr) { return *ptr; } -__device__ short __ldg(const short*); -__device__ short2 __ldg(const short2*); -__device__ short4 __ldg(const short4*); -__device__ unsigned short __ldg(const unsigned short*); +__device__ inline static char2 __ldg(const char2* ptr) { return *ptr; } -__device__ int __ldg(const int*); -__device__ int2 __ldg(const int2*); -__device__ int4 __ldg(const int4*); -__device__ unsigned int __ldg(const unsigned int*); +__device__ inline static char4 __ldg(const char4* ptr) { return *ptr; } + +__device__ inline static signed char __ldg(const signed char* ptr) { return ptr[0]; } + +__device__ inline static unsigned char __ldg(const unsigned char* ptr) { return ptr[0]; } -__device__ long __ldg(const long*); -__device__ unsigned long __ldg(const unsigned long*); +__device__ inline static short __ldg(const short* ptr) { return ptr[0]; } -__device__ long long __ldg(const long long*); -__device__ longlong2 __ldg(const longlong2*); -__device__ unsigned long long __ldg(const unsigned long long*); +__device__ inline static short2 __ldg(const short2* ptr) { return ptr[0]; } -__device__ uchar2 __ldg(const uchar2*); -__device__ uchar4 __ldg(const uchar4*); +__device__ inline static short4 __ldg(const short4* ptr) { return ptr[0]; } -__device__ ushort2 __ldg(const ushort2*); +__device__ inline static unsigned short __ldg(const unsigned short* ptr) { return ptr[0]; } -__device__ uint2 __ldg(const uint2*); -__device__ uint4 __ldg(const uint4*); -__device__ ulonglong2 __ldg(const ulonglong2*); +__device__ inline static int __ldg(const int* ptr) { return ptr[0]; } -__device__ float __ldg(const float*); -__device__ float2 __ldg(const float2*); -__device__ float4 __ldg(const float4*); +__device__ inline static int2 __ldg(const int2* ptr) { return ptr[0]; } -__device__ double __ldg(const double*); -__device__ double2 __ldg(const double2*); +__device__ inline static int4 __ldg(const int4* ptr) { return ptr[0]; } -#endif // __hcc_workweek__ +__device__ inline static unsigned int __ldg(const unsigned int* ptr) { return ptr[0]; } -#endif // __HCC__ + +__device__ inline static long __ldg(const long* ptr) { return ptr[0]; } + +__device__ inline static unsigned long __ldg(const unsigned long* ptr) { return ptr[0]; } + + +__device__ inline static long long __ldg(const long long* ptr) { return ptr[0]; } + +__device__ inline static longlong2 __ldg(const longlong2* ptr) { return ptr[0]; } + +__device__ inline static unsigned long long __ldg(const unsigned long long* ptr) { return ptr[0]; } + + +__device__ inline static uchar2 __ldg(const uchar2* ptr) { return ptr[0]; } + +__device__ inline static uchar4 __ldg(const uchar4* ptr) { return ptr[0]; } + + +__device__ inline static ushort2 __ldg(const ushort2* ptr) { return ptr[0]; } + + +__device__ inline static uint2 __ldg(const uint2* ptr) { return ptr[0]; } + +__device__ inline static uint4 __ldg(const uint4* ptr) { return ptr[0]; } + + +__device__ inline static ulonglong2 __ldg(const ulonglong2* ptr) { return ptr[0]; } + + +__device__ inline static float __ldg(const float* ptr) { return ptr[0]; } + +__device__ inline static float2 __ldg(const float2* ptr) { return ptr[0]; } + +__device__ inline static float4 __ldg(const float4* ptr) { return ptr[0]; } + + +__device__ inline static double __ldg(const double* ptr) { return ptr[0]; } + +__device__ inline static double2 __ldg(const double2* ptr) { return ptr[0]; } + +#endif // __hcc_workweek__ || defined(__HIP_CLANG_ONLY__) + +#endif // defined(__HCC_OR_HIP_CLANG__) #endif // HIP_LDG_H diff --git a/projects/hip/include/hip/hcc_detail/hip_runtime.h b/projects/hip/include/hip/hcc_detail/hip_runtime.h index f67da8d51e..13eaf4fda4 100644 --- a/projects/hip/include/hip/hcc_detail/hip_runtime.h +++ b/projects/hip/include/hip/hcc_detail/hip_runtime.h @@ -110,9 +110,9 @@ extern int HIP_TRACE_API; #include #include #include +#include #if __HCC__ #include -#include #endif // __HCC__ // TODO-HCC remove old definitions ; ~1602 hcc supports __HCC_ACCELERATOR__ define. @@ -184,45 +184,11 @@ extern int HIP_TRACE_API; #define __HCC_C__ #endif -// TODO - hipify-clang - change to use the function call. -//#define warpSize hc::__wavesize() -static constexpr int warpSize = 64; - -#define clock_t long long int -__device__ long long int clock64(); -__device__ clock_t clock(); - // abort __device__ void abort(); -// warp vote function __all __any __ballot -__device__ int __all(int input); -__device__ int __any(int input); -__device__ unsigned long long int __ballot(int input); - #if __HIP_ARCH_GFX701__ == 0 -// warp shuffle functions -#ifdef __cplusplus -__device__ int __shfl(int input, int lane, int width = warpSize); -__device__ int __shfl_up(int input, unsigned int lane_delta, int width = warpSize); -__device__ int __shfl_down(int input, unsigned int lane_delta, int width = warpSize); -__device__ int __shfl_xor(int input, int lane_mask, int width = warpSize); -__device__ float __shfl(float input, int lane, int width = warpSize); -__device__ float __shfl_up(float input, unsigned int lane_delta, int width = warpSize); -__device__ float __shfl_down(float input, unsigned int lane_delta, int width = warpSize); -__device__ float __shfl_xor(float input, int lane_mask, int width = warpSize); -#else -__device__ int __shfl(int input, int lane, int width); -__device__ int __shfl_up(int input, unsigned int lane_delta, int width); -__device__ int __shfl_down(int input, unsigned int lane_delta, int width); -__device__ int __shfl_xor(int input, int lane_mask, int width); -__device__ float __shfl(float input, int lane, int width); -__device__ float __shfl_up(float input, unsigned int lane_delta, int width); -__device__ float __shfl_down(float input, unsigned int lane_delta, int width); -__device__ float __shfl_xor(float input, int lane_mask, int width); -#endif //__cplusplus - __device__ unsigned __hip_ds_bpermute(int index, unsigned src); __device__ float __hip_ds_bpermutef(int index, float src); __device__ unsigned __hip_ds_permute(int index, unsigned src); @@ -235,85 +201,15 @@ __device__ int __hip_move_dpp(int src, int dpp_ctrl, int row_mask, int bank_mask #endif //__HIP_ARCH_GFX803__ == 1 -__host__ __device__ int min(int arg1, int arg2); -__host__ __device__ int max(int arg1, int arg2); +__device__ inline static int min(int arg1, int arg2) { + return (arg1 < arg2) ? arg1 : arg2; +} +__device__ inline static int max(int arg1, int arg2) { + return (arg1 > arg2) ? arg1 : arg2; +} -__device__ void* __get_dynamicgroupbaseptr(); - - -/** - * CUDA 8 device function features - - */ - - -/** - * Kernel launching - */ - -/** - *------------------------------------------------------------------------------------------------- - *------------------------------------------------------------------------------------------------- - * @defgroup Fence Fence Functions - * @{ - * - * - * @warning The HIP memory fence functions are currently not supported yet. - * If any of those threadfence stubs are reached by the application, you should set "export - *HSA_DISABLE_CACHE=1" to disable L1 and L2 caches. - * - * - * On AMD platforms, the threadfence* routines are currently empty stubs. - */ - -extern __attribute__((const)) __device__ void __hip_hc_threadfence() __asm("__llvm_fence_sc_dev"); -extern __attribute__((const)) __device__ void __hip_hc_threadfence_block() __asm( - "__llvm_fence_sc_wg"); - - -/** - * @brief threadfence_block makes writes visible to threads running in same block. - * - * @Returns void - * - * @param void - * - * @warning __threadfence_block is a stub and map to no-op. - */ -// __device__ void __threadfence_block(void); -__device__ static inline void __threadfence_block(void) { return __hip_hc_threadfence_block(); } - -/** - * @brief threadfence makes wirtes visible to other threads running on same GPU. - * - * @Returns void - * - * @param void - * - * @warning __threadfence is a stub and map to no-op, application should set "export - * HSA_DISABLE_CACHE=1" to disable both L1 and L2 caches. - */ -// __device__ void __threadfence(void) __attribute__((deprecated("Provided for compile-time -// compatibility, not yet functional"))); -__device__ static inline void __threadfence(void) { return __hip_hc_threadfence(); } - -/** - * @brief threadfence_system makes writes to pinned system memory visible on host CPU. - * - * @Returns void - * - * @param void - * - * @warning __threadfence_system is a stub and map to no-op. - */ -//__device__ void __threadfence_system(void) __attribute__((deprecated("Provided with workaround -//configuration, see hip_kernel_language.md for details"))); -__device__ void __threadfence_system(void); - -// doxygen end Fence Fence -/** - * @} - */ +__host__ inline static int min(int arg1, int arg2) { return std::min(arg1, arg2); } +__host__ inline static int max(int arg1, int arg2) { return std::max(arg1, arg2); } #endif // __HCC_OR_HIP_CLANG__ @@ -437,17 +333,6 @@ extern void ihipPostLaunchKernel(const char* kernelName, hipStream_t stream, gri #endif //__HCC_CPP__ -/** - * extern __shared__ - */ - -// Macro to replace extern __shared__ declarations -// to local variable definitions -#define HIP_DYNAMIC_SHARED(type, var) type* var = (type*)__get_dynamicgroupbaseptr(); - -#define HIP_DYNAMIC_SHARED_ATTRIBUTE - - /** * @defgroup HIP-ENV HIP Environment Variables * @{ @@ -566,33 +451,6 @@ extern const __device__ __attribute__((weak)) __hip_builtin_gridDim_t gridDim; #define hipGridDim_y gridDim.y #define hipGridDim_z gridDim.z -#pragma push_macro("__DEVICE__") -#define __DEVICE__ extern "C" __device__ __attribute__((always_inline)) \ - __attribute__((weak)) - -__DEVICE__ void __device_trap() __asm("llvm.trap"); - -__DEVICE__ void inline __assert_fail(const char * __assertion, - const char *__file, - unsigned int __line, - const char *__function) -{ - // Ignore all the args for now. - __device_trap(); -} - -extern "C" __device__ __attribute__((noduplicate)) void __syncthreads(); -extern "C" __device__ void *__amdgcn_get_dynamicgroupbaseptr(); - -// Macro to replace extern __shared__ declarations -// to local variable definitions -#define HIP_DYNAMIC_SHARED(type, var) \ - type* var = (type*)__amdgcn_get_dynamicgroupbaseptr(); - -#define HIP_DYNAMIC_SHARED_ATTRIBUTE - -#pragma push_macro("__DEVICE__") - #include #endif diff --git a/projects/hip/include/hip/hcc_detail/hip_vector_types.h b/projects/hip/include/hip/hcc_detail/hip_vector_types.h index 7cd250e257..cf7058af2b 100644 --- a/projects/hip/include/hip/hcc_detail/hip_vector_types.h +++ b/projects/hip/include/hip/hcc_detail/hip_vector_types.h @@ -34,1132 +34,679 @@ THE SOFTWARE. #include "hip/hcc_detail/host_defines.h" -#define MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(type) \ - __device__ __host__ type() {} \ - __device__ __host__ type(const type& val) : x(val.x) {} \ - __device__ __host__ ~type() {} - -#define MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(type) \ - __device__ __host__ type() {} \ - __device__ __host__ type(const type& val) : x(val.x), y(val.y) {} \ - __device__ __host__ ~type() {} - -#define MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(type) \ - __device__ __host__ type() {} \ - __device__ __host__ type(const type& val) : x(val.x), y(val.y), z(val.z) {} \ - __device__ __host__ ~type() {} - -#define MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(type) \ - __device__ __host__ type() {} \ - __device__ __host__ type(const type& val) : x(val.x), y(val.y), z(val.z), w(val.w) {} \ - __device__ __host__ ~type() {} - -#define MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(type, type1) \ - __device__ __host__ type(type1 val) : x(val) {} - -#define MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(type, type1) \ - __device__ __host__ type(type1 val) : x(val), y(val) {} \ - __device__ __host__ type(type1 val1, type1 val2) : x(val1), y(val2) {} - -#define MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(type, type1) \ - __device__ __host__ type(type1 val) : x(val), y(val), z(val) {} \ - __device__ __host__ type(type1 val1, type1 val2, type1 val3) : x(val1), y(val2), z(val3) {} - -#define MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(type, type1) \ - __device__ __host__ type(type1 val) : x(val), y(val), z(val), w(val) {} \ - __device__ __host__ type(type1 val1, type1 val2, type1 val3, type1 val4) \ - : x(val1), y(val2), z(val3), w(val4) {} - -struct uchar1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(uchar1) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, signed long long) - +#if defined(__clang__) + #define __NATIVE_VECTOR__(n, ...) __attribute__((ext_vector_type(n))) +#elif defined(__GNUC__) // N.B.: GCC does not support .xyzw syntax. + #define __ROUND_UP_TO_NEXT_POT__(x) \ + (1 << (31 - __builtin_clz(x) + (x > (1 << (31 - __builtin_clz(x)))))) + #define __NATIVE_VECTOR__(n, T) \ + __attribute__((vector_size(__ROUND_UP_TO_NEXT_POT__(n) * sizeof(T)))) #endif - unsigned char x; -} __attribute__((aligned(1))); +#if defined(__cplusplus) + #include -struct uchar2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(uchar2) + template struct HIP_vector_base; - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, signed long long) -#endif - union { - struct { - unsigned char x, y; + template + struct HIP_vector_base { + typedef T Native_vec_ __NATIVE_VECTOR__(1, T); + + union { + Native_vec_ data; + struct { + T x; + }; }; - unsigned short a; - }; -} __attribute__((aligned(2))); - -struct uchar3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(uchar3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, signed long long) -#endif - unsigned char x, y, z; -}; - -struct uchar4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(uchar4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, signed long long) -#endif - union { - struct { - unsigned char x, y, z, w; - }; - unsigned int a; - }; -} __attribute__((aligned(4))); - - -struct char1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(char1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, signed long long) -#endif - signed char x; -} __attribute__((aligned(1))); - -struct char2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(char2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, signed long long) -#endif - union { - struct { - signed char x, y; - }; - unsigned short a; - }; -} __attribute__((aligned(2))); - -struct char3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(char3) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, signed long long) -#endif - signed char x, y, z; -}; - -struct char4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(char4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, signed long long) -#endif - union { - struct { - signed char x, y, z, w; - }; - unsigned int a; - }; -} __attribute__((aligned(4))); - - -struct ushort1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(ushort1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, signed long long) -#endif - unsigned short x; -} __attribute__((aligned(2))); - -struct ushort2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(ushort2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, signed long long) -#endif - union { - struct { - unsigned short x, y; - }; - unsigned int a; - }; -} __attribute__((aligned(4))); - -struct ushort3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(ushort3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, signed long long) -#endif - unsigned short x, y, z; -}; - -struct ushort4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(ushort4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, signed long long) -#endif - union { - struct { - unsigned short x, y, z, w; - }; - unsigned int a, b; - }; -} __attribute__((aligned(8))); - -struct short1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(short1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, signed long long) -#endif - signed short x; -} __attribute__((aligned(2))); - -struct short2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(short2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, signed long long) -#endif - union { - struct { - signed short x, y; - }; - unsigned int a; }; -} __attribute__((aligned(4))); + template + struct HIP_vector_base { + typedef T Native_vec_ __NATIVE_VECTOR__(2, T); -struct short3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(short3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, signed long long) -#endif - signed short x, y, z; -}; - -struct short4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(short4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, signed long long) -#endif - union { - struct { - signed short x, y, z, w; + union { + Native_vec_ data; + struct { + T x; + T y; + }; }; - unsigned int a, b; }; -} __attribute__((aligned(8))); - -struct uint1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(uint1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, signed long long) -#endif - unsigned int x; -} __attribute__((aligned(4))); - -struct uint2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(uint2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, signed long long) -#endif - unsigned int x, y; -} __attribute__((aligned(8))); - -struct uint3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(uint3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, signed long long) -#endif - unsigned int x, y, z; -}; - -struct uint4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(uint4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, signed long long) -#endif - unsigned int x, y, z, w; -} __attribute__((aligned(16))); - -struct int1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(int1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, signed long long) -#endif - signed int x; -} __attribute__((aligned(4))); - -struct int2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(int2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, signed long long) -#endif - signed int x, y; -} __attribute__((aligned(8))); - -struct int3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(int3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, signed long long) -#endif - signed int x, y, z; -}; - -struct int4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(int4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, signed long long) -#endif - signed int x, y, z, w; -} __attribute__((aligned(16))); - - -struct float1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(float1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, signed long long) -#endif - float x; -} __attribute__((aligned(4))); - -struct float2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(float2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, signed long long) -#endif - float x, y; -} __attribute__((aligned(8))); - -struct float3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(float3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, signed long long) -#endif - float x, y, z; -}; - -struct float4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(float4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, signed long long) -#endif - float x, y, z, w; -} __attribute__((aligned(16))); - - -struct double1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(double1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, signed long long) -#endif - double x; -} __attribute__((aligned(8))); - -struct double2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(double2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, signed long long) -#endif - double x, y; -} __attribute__((aligned(16))); - -struct double3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(double3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, signed long long) -#endif - double x, y, z; -}; - -struct double4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(double4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, signed long long) -#endif - double x, y, z, w; -} __attribute__((aligned(32))); - - -struct ulong1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(ulong1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, signed long long) -#endif - unsigned long x; -} __attribute__((aligned(8))); - -struct ulong2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(ulong2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, signed long long) -#endif - unsigned long x, y; -} __attribute__((aligned(16))); - -struct ulong3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(ulong3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, signed long long) -#endif - unsigned long x, y, z; -}; - -struct ulong4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(ulong4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, signed long long) -#endif - unsigned long x, y, z, w; -} __attribute__((aligned(32))); - - -struct long1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(long1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, signed long long) -#endif - signed long x; -} __attribute__((aligned(8))); - -struct long2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(long2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, signed long long) -#endif - signed long x, y; -} __attribute__((aligned(16))); - -struct long3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(long3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, signed long long) -#endif - signed long x, y, z; -}; - -struct long4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(long4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, signed long long) -#endif - signed long x, y, z, w; -} __attribute__((aligned(32))); - - -struct ulonglong1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, signed long long) -#endif - unsigned long long x; -} __attribute__((aligned(8))); - -struct ulonglong2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, signed long long) -#endif - unsigned long long x, y; -} __attribute__((aligned(16))); - -struct ulonglong3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, signed long long) -#endif - unsigned long long x, y, z; -}; - -struct ulonglong4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, signed long long) -#endif - unsigned long long x, y, z, w; -} __attribute__((aligned(32))); - - -struct longlong1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(longlong1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, signed long long) -#endif - signed long long x; -} __attribute__((aligned(8))); - -struct longlong2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(longlong2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, signed long long) -#endif - signed long long x, y; -} __attribute__((aligned(16))); - -struct longlong3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(longlong3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, signed long long) -#endif - signed long long x, y, z; -}; - -struct longlong4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(longlong4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, signed long long) -#endif - signed long x, y, z, w; -} __attribute__((aligned(32))); - -#define DECLOP_MAKE_ONE_COMPONENT(comp, type) \ - __device__ __host__ static inline struct type make_##type(comp x) { \ - struct type ret; \ - ret.x = x; \ - return ret; \ + template + struct HIP_vector_base { + typedef T Native_vec_ __NATIVE_VECTOR__(3, T); + + union { + Native_vec_ data; + struct { + T x; + T y; + T z; + }; + }; + }; + + template + struct HIP_vector_base { + typedef T Native_vec_ __NATIVE_VECTOR__(4, T); + + union { + Native_vec_ data; + struct { + T x; + T y; + T z; + T w; + }; + }; + }; + + template + struct HIP_vector_type : public HIP_vector_base { + using HIP_vector_base::data; + using typename HIP_vector_base::Native_vec_; + + __host__ __device__ + HIP_vector_type() = default; + template< + typename U, + typename std::enable_if< + std::is_convertible{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type(U x) noexcept + { + for (auto i = 0u; i != rank; ++i) data[i] = x; + } + template< // TODO: constrain based on type as well. + typename... Us, + typename std::enable_if::type* = nullptr> + __host__ __device__ + HIP_vector_type(Us... xs) noexcept { data = Native_vec_{xs...}; } + __host__ __device__ + HIP_vector_type(const HIP_vector_type&) = default; + __host__ __device__ + HIP_vector_type(HIP_vector_type&&) = default; + __host__ __device__ + ~HIP_vector_type() = default; + + __host__ __device__ + HIP_vector_type& operator=(const HIP_vector_type&) = default; + __host__ __device__ + HIP_vector_type& operator=(HIP_vector_type&&) = default; + + // Operators + __host__ __device__ + HIP_vector_type& operator++() noexcept + { + return *this += HIP_vector_type{1}; + } + __host__ __device__ + HIP_vector_type operator++(int) noexcept + { + auto tmp(*this); + ++*this; + return tmp; + } + __host__ __device__ + HIP_vector_type& operator--() noexcept + { + return *this -= HIP_vector_type{1}; + } + __host__ __device__ + HIP_vector_type operator--(int) noexcept + { + auto tmp(*this); + --*this; + return tmp; + } + __host__ __device__ + HIP_vector_type& operator+=(const HIP_vector_type& x) noexcept + { + data += x.data; + return *this; + } + __host__ __device__ + HIP_vector_type& operator-=(const HIP_vector_type& x) noexcept + { + data -= x.data; + return *this; + } + template< + typename U, + typename std::enable_if< + std::is_convertible{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type& operator-=(U x) noexcept + { + return *this -= HIP_vector_type{x}; + } + __host__ __device__ + HIP_vector_type& operator*=(const HIP_vector_type& x) noexcept + { + data *= x.data; + return *this; + } + __host__ __device__ + HIP_vector_type& operator/=(const HIP_vector_type& x) noexcept + { + data /= x.data; + return *this; + } + + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type operator-() noexcept + { + auto tmp(*this); + tmp.data = -tmp.data; + return tmp; + } + + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type operator~() noexcept + { + HIP_vector_type r{*this}; + r.data = ~r.data; + return r; + } + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type& operator%=(const HIP_vector_type& x) noexcept + { + data %= x.data; + return *this; + } + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type& operator^=(const HIP_vector_type& x) noexcept + { + data ^= x.data; + return *this; + } + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type& operator|=(const HIP_vector_type& x) noexcept + { + data |= x.data; + return *this; + } + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type& operator&=(const HIP_vector_type& x) noexcept + { + data &= x.data; + return *this; + } + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type& operator>>=(const HIP_vector_type& x) noexcept + { + data >>= x.data; + return *this; + } + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type& operator<<=(const HIP_vector_type& x) noexcept + { + data <<= x.data; + return *this; + } + }; + + + template + __host__ __device__ + inline + HIP_vector_type operator+( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} += y; + } + template + __host__ __device__ + inline + HIP_vector_type operator+( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} += y; + } + template + __host__ __device__ + inline + HIP_vector_type operator+( + U x, const HIP_vector_type& y) noexcept + { + return y + x; } -#define DECLOP_MAKE_TWO_COMPONENT(comp, type) \ - __device__ __host__ static inline struct type make_##type(comp x, comp y) { \ - struct type ret; \ - ret.x = x; \ - ret.y = y; \ - return ret; \ + template + __host__ __device__ + inline + HIP_vector_type operator-( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} -= y; + } + template + __host__ __device__ + inline + HIP_vector_type operator-( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} -= y; + } + template + __host__ __device__ + inline + HIP_vector_type operator-( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} -= y; } -#define DECLOP_MAKE_THREE_COMPONENT(comp, type) \ - __device__ __host__ static inline struct type make_##type(comp x, comp y, comp z) { \ - struct type ret; \ - ret.x = x; \ - ret.y = y; \ - ret.z = z; \ - return ret; \ + template + __host__ __device__ + inline + HIP_vector_type operator*( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} *= y; + } + template + __host__ __device__ + inline + HIP_vector_type operator*( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} *= y; + } + template + __host__ __device__ + inline + HIP_vector_type operator*( + U x, const HIP_vector_type& y) noexcept + { + return y * x; } -#define DECLOP_MAKE_FOUR_COMPONENT(comp, type) \ - __device__ __host__ static inline struct type make_##type(comp x, comp y, comp z, comp w) { \ - struct type ret; \ - ret.x = x; \ - ret.y = y; \ - ret.z = z; \ - ret.w = w; \ - return ret; \ + template + __host__ __device__ + inline + HIP_vector_type operator/( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} /= y; + } + template + __host__ __device__ + inline + HIP_vector_type operator/( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} /= y; + } + template + __host__ __device__ + inline + HIP_vector_type operator/( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} /= y; + } + + template + __host__ __device__ + inline + bool operator==( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + auto tmp = x.data == y.data; + for (auto i = 0u; i != n; ++i) if (tmp[i] == 0) return false; + return true; + } + template + __host__ __device__ + inline + bool operator==(const HIP_vector_type& x, U y) noexcept + { + return x == HIP_vector_type{y}; + } + template + __host__ __device__ + inline + bool operator==(U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} == y; + } + + template + __host__ __device__ + inline + bool operator!=( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return !(x == y); + } + template + __host__ __device__ + inline + bool operator!=(const HIP_vector_type& x, U y) noexcept + { + return !(x == y); + } + template + __host__ __device__ + inline + bool operator!=(U x, const HIP_vector_type& y) noexcept + { + return !(x == y); + } + + template< + typename T, + unsigned int n, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator%( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} %= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator%( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} %= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator%( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} %= y; + } + + template< + typename T, + unsigned int n, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator^( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} ^= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator^( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} ^= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator^( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} ^= y; + } + + template< + typename T, + unsigned int n, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator|( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} |= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator|( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} |= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator|( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} |= y; + } + + template< + typename T, + unsigned int n, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator&( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} &= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator&( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} &= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator&( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} &= y; + } + + template< + typename T, + unsigned int n, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator>>( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} >>= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator>>( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} >>= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator>>( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} >>= y; + } + + template< + typename T, + unsigned int n, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator<<( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} <<= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator<<( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} <<= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator<<( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} <<= y; + } + + #define __MAKE_VECTOR_TYPE__(CUDA_name, T) \ + using CUDA_name##1 = HIP_vector_type;\ + using CUDA_name##2 = HIP_vector_type;\ + using CUDA_name##3 = HIP_vector_type;\ + using CUDA_name##4 = HIP_vector_type; +#else + #define __MAKE_VECTOR_TYPE__(CUDA_name, T) \ + typedef T CUDA_name##_impl1 __NATIVE_VECTOR__(1, T);\ + typedef T CUDA_name##_impl2 __NATIVE_VECTOR__(2, T);\ + typedef T CUDA_name##_impl3 __NATIVE_VECTOR__(3, T);\ + typedef T CUDA_name##_impl4 __NATIVE_VECTOR__(4, T);\ + typedef struct {\ + union {\ + CUDA_name##_impl1 data;\ + struct {\ + T x;\ + };\ + };\ + } CUDA_name##1;\ + typedef struct {\ + union {\ + CUDA_name##_impl2 data;\ + struct {\ + T x;\ + T y;\ + };\ + };\ + } CUDA_name##2;\ + typedef struct {\ + union {\ + CUDA_name##_impl3 data;\ + struct {\ + T x;\ + T y;\ + T z;\ + };\ + };\ + } CUDA_name##3;\ + typedef struct {\ + union {\ + CUDA_name##_impl4 data;\ + struct {\ + T x;\ + T y;\ + T z;\ + T w;\ + };\ + };\ + } CUDA_name##4; +#endif + +__MAKE_VECTOR_TYPE__(uchar, unsigned char); +__MAKE_VECTOR_TYPE__(char, char); +__MAKE_VECTOR_TYPE__(ushort, unsigned short); +__MAKE_VECTOR_TYPE__(short, short); +__MAKE_VECTOR_TYPE__(uint, unsigned int); +__MAKE_VECTOR_TYPE__(int, int); +__MAKE_VECTOR_TYPE__(ulong, unsigned long); +__MAKE_VECTOR_TYPE__(long, long); +__MAKE_VECTOR_TYPE__(ulonglong, unsigned long long); +__MAKE_VECTOR_TYPE__(longlong, long long); +__MAKE_VECTOR_TYPE__(float, float); +__MAKE_VECTOR_TYPE__(double, double); + +#define DECLOP_MAKE_ONE_COMPONENT(comp, type) \ + __device__ __host__ \ + static \ + inline \ + type make_##type(comp x) { type r = {x}; return r; } + +#define DECLOP_MAKE_TWO_COMPONENT(comp, type) \ + __device__ __host__ \ + static \ + inline \ + type make_##type(comp x, comp y) { type r = {x, y}; return r; } + +#define DECLOP_MAKE_THREE_COMPONENT(comp, type) \ + __device__ __host__ \ + static \ + inline \ + type make_##type(comp x, comp y, comp z) { type r = {x, y, z}; return r; } + +#define DECLOP_MAKE_FOUR_COMPONENT(comp, type) \ + __device__ __host__ \ + static \ + inline \ + type make_##type(comp x, comp y, comp z, comp w) { \ + type r = {x, y, z, w}; \ + return r; \ } DECLOP_MAKE_ONE_COMPONENT(unsigned char, uchar1); @@ -1222,2894 +769,4 @@ DECLOP_MAKE_TWO_COMPONENT(signed long, longlong2); DECLOP_MAKE_THREE_COMPONENT(signed long, longlong3); DECLOP_MAKE_FOUR_COMPONENT(signed long, longlong4); - -#if __cplusplus - -#define DECLOP_1VAR_2IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(const type& lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs.x op rhs.x; \ - return ret; \ - } - -#define DECLOP_1VAR_SCALE_PRODUCT(type, type1) \ - __device__ __host__ static inline type operator*(const type& lhs, type1 rhs) { \ - type ret; \ - ret.x = lhs.x * rhs; \ - return ret; \ - } \ - \ - __device__ __host__ static inline type operator*(type1 lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs * rhs.x; \ - return ret; \ - } - -#define DECLOP_1VAR_ASSIGN(type, op) \ - __device__ __host__ static inline type& operator op(type& lhs, const type& rhs) { \ - lhs.x op rhs.x; \ - return lhs; \ - } - -#define DECLOP_1VAR_PREOP(type, op) \ - __device__ __host__ static inline type& operator op(type& val) { \ - op val.x; \ - return val; \ - } - -#define DECLOP_1VAR_POSTOP(type, op) \ - __device__ __host__ static inline type operator op(type& val, int) { \ - type ret; \ - ret.x = val.x; \ - val.x op; \ - return ret; \ - } - -#define DECLOP_1VAR_COMP(type, op) \ - __device__ __host__ static inline bool operator op(type& lhs, type& rhs) { \ - return lhs.x op rhs.x; \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, type& rhs) { \ - return lhs.x op rhs.x; \ - } \ - __device__ __host__ static inline bool operator op(type& lhs, const type& rhs) { \ - return lhs.x op rhs.x; \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, const type& rhs) { \ - return lhs.x op rhs.x; \ - } - -#define DECLOP_1VAR_1IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(type& rhs) { \ - type ret; \ - ret.x = op rhs.x; \ - return ret; \ - } - -#define DECLOP_1VAR_1IN_BOOLOUT(type, op) \ - __device__ __host__ static inline bool operator op(type& rhs) { return op rhs.x; } - -/* - Two Element Access -*/ - -#define DECLOP_2VAR_2IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(const type& lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs.x op rhs.x; \ - ret.y = lhs.y op rhs.y; \ - return ret; \ - } - -#define DECLOP_2VAR_SCALE_PRODUCT(type, type1) \ - __device__ __host__ static inline type operator*(const type& lhs, type1 rhs) { \ - type ret; \ - ret.x = lhs.x * rhs; \ - ret.y = lhs.y * rhs; \ - return ret; \ - } \ - \ - __device__ __host__ static inline type operator*(type1 lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs * rhs.x; \ - ret.y = lhs * rhs.y; \ - return ret; \ - } - -#define DECLOP_2VAR_ASSIGN(type, op) \ - __device__ __host__ static inline type& operator op(type& lhs, const type& rhs) { \ - lhs.x op rhs.x; \ - lhs.y op rhs.y; \ - return lhs; \ - } - -#define DECLOP_2VAR_PREOP(type, op) \ - __device__ __host__ static inline type& operator op(type& val) { \ - op val.x; \ - op val.y; \ - return val; \ - } - -#define DECLOP_2VAR_POSTOP(type, op) \ - __device__ __host__ static inline type operator op(type& val, int) { \ - type ret; \ - ret.x = val.x; \ - ret.y = val.y; \ - val.x op; \ - val.y op; \ - return ret; \ - } - -#define DECLOP_2VAR_COMP(type, op) \ - __device__ __host__ static inline bool operator op(type& lhs, type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y); \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y); \ - } \ - __device__ __host__ static inline bool operator op(type& lhs, const type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y); \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, const type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y); \ - } - -#define DECLOP_2VAR_1IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(type& rhs) { \ - type ret; \ - ret.x = op rhs.x; \ - ret.y = op rhs.y; \ - return ret; \ - } - -#define DECLOP_2VAR_1IN_BOOLOUT(type, op) \ - __device__ __host__ static inline bool operator op(type& rhs) { \ - return (op rhs.x) && (op rhs.y); \ - } - - -/* - Three Element Access -*/ - -#define DECLOP_3VAR_2IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(const type& lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs.x op rhs.x; \ - ret.y = lhs.y op rhs.y; \ - ret.z = lhs.z op rhs.z; \ - return ret; \ - } - -#define DECLOP_3VAR_SCALE_PRODUCT(type, type1) \ - __device__ __host__ static inline type operator*(const type& lhs, type1 rhs) { \ - type ret; \ - ret.x = lhs.x * rhs; \ - ret.y = lhs.y * rhs; \ - ret.z = lhs.z * rhs; \ - return ret; \ - } \ - \ - __device__ __host__ static inline type operator*(type1 lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs * rhs.x; \ - ret.y = lhs * rhs.y; \ - ret.z = lhs * rhs.z; \ - return ret; \ - } - -#define DECLOP_3VAR_ASSIGN(type, op) \ - __device__ __host__ static inline type& operator op(type& lhs, const type& rhs) { \ - lhs.x op rhs.x; \ - lhs.y op rhs.y; \ - lhs.z op rhs.z; \ - return lhs; \ - } - -#define DECLOP_3VAR_PREOP(type, op) \ - __device__ __host__ static inline type& operator op(type& val) { \ - op val.x; \ - op val.y; \ - op val.z; \ - return val; \ - } - -#define DECLOP_3VAR_POSTOP(type, op) \ - __device__ __host__ static inline type operator op(type& val, int) { \ - type ret; \ - ret.x = val.x; \ - ret.y = val.y; \ - ret.z = val.z; \ - val.x op; \ - val.y op; \ - val.z op; \ - return ret; \ - } - -#define DECLOP_3VAR_COMP(type, op) \ - __device__ __host__ static inline bool operator op(type& lhs, type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z); \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z); \ - } \ - __device__ __host__ static inline bool operator op(type& lhs, const type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z); \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, const type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z); \ - } - -#define DECLOP_3VAR_1IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(type& rhs) { \ - type ret; \ - ret.x = op rhs.x; \ - ret.y = op rhs.y; \ - ret.z = op rhs.z; \ - return ret; \ - } - -#define DECLOP_3VAR_1IN_BOOLOUT(type, op) \ - __device__ __host__ static inline bool operator op(type& rhs) { \ - return (op rhs.x) && (op rhs.y) && (op rhs.z); \ - } - - -/* - Four Element Access -*/ - -#define DECLOP_4VAR_2IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(const type& lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs.x op rhs.x; \ - ret.y = lhs.y op rhs.y; \ - ret.z = lhs.z op rhs.z; \ - ret.w = lhs.w op rhs.w; \ - return ret; \ - } - -#define DECLOP_4VAR_SCALE_PRODUCT(type, type1) \ - __device__ __host__ static inline type operator*(const type& lhs, type1 rhs) { \ - type ret; \ - ret.x = lhs.x * rhs; \ - ret.y = lhs.y * rhs; \ - ret.z = lhs.z * rhs; \ - ret.w = lhs.w * rhs; \ - return ret; \ - } \ - \ - __device__ __host__ static inline type operator*(type1 lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs * rhs.x; \ - ret.y = lhs * rhs.y; \ - ret.z = lhs * rhs.z; \ - ret.w = lhs * rhs.w; \ - return ret; \ - } - -#define DECLOP_4VAR_ASSIGN(type, op) \ - __device__ __host__ static inline type& operator op(type& lhs, const type& rhs) { \ - lhs.x op rhs.x; \ - lhs.y op rhs.y; \ - lhs.z op rhs.z; \ - lhs.w op rhs.w; \ - return lhs; \ - } - -#define DECLOP_4VAR_PREOP(type, op) \ - __device__ __host__ static inline type& operator op(type& val) { \ - op val.x; \ - op val.y; \ - op val.z; \ - op val.w; \ - return val; \ - } - -#define DECLOP_4VAR_POSTOP(type, op) \ - __device__ __host__ static inline type operator op(type& val, int) { \ - type ret; \ - ret.x = val.x; \ - ret.y = val.y; \ - ret.z = val.z; \ - ret.w = val.w; \ - val.x op; \ - val.y op; \ - val.z op; \ - val.w op; \ - return ret; \ - } - -#define DECLOP_4VAR_COMP(type, op) \ - __device__ __host__ static inline bool operator op(type& lhs, type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z) && (lhs.w op rhs.w); \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z) && (lhs.w op rhs.w); \ - } \ - __device__ __host__ static inline bool operator op(type& lhs, const type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z) && (lhs.w op rhs.w); \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, const type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z) && (lhs.w op rhs.w); \ - } - -#define DECLOP_4VAR_1IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(type& rhs) { \ - type ret; \ - ret.x = op rhs.x; \ - ret.y = op rhs.y; \ - ret.z = op rhs.z; \ - ret.w = op rhs.w; \ - return ret; \ - } - -#define DECLOP_4VAR_1IN_BOOLOUT(type, op) \ - __device__ __host__ static inline bool operator op(type& rhs) { \ - return (op rhs.x) && (op rhs.y) && (op rhs.z) && (op rhs.w); \ - } - - -/* -Overloading operators -*/ - -// UNSIGNED CHAR1 - -DECLOP_1VAR_2IN_1OUT(uchar1, +) -DECLOP_1VAR_2IN_1OUT(uchar1, -) -DECLOP_1VAR_2IN_1OUT(uchar1, *) -DECLOP_1VAR_2IN_1OUT(uchar1, /) -DECLOP_1VAR_2IN_1OUT(uchar1, %) -DECLOP_1VAR_2IN_1OUT(uchar1, &) -DECLOP_1VAR_2IN_1OUT(uchar1, |) -DECLOP_1VAR_2IN_1OUT(uchar1, ^) -DECLOP_1VAR_2IN_1OUT(uchar1, <<) -DECLOP_1VAR_2IN_1OUT(uchar1, >>) - - -DECLOP_1VAR_ASSIGN(uchar1, +=) -DECLOP_1VAR_ASSIGN(uchar1, -=) -DECLOP_1VAR_ASSIGN(uchar1, *=) -DECLOP_1VAR_ASSIGN(uchar1, /=) -DECLOP_1VAR_ASSIGN(uchar1, %=) -DECLOP_1VAR_ASSIGN(uchar1, &=) -DECLOP_1VAR_ASSIGN(uchar1, |=) -DECLOP_1VAR_ASSIGN(uchar1, ^=) -DECLOP_1VAR_ASSIGN(uchar1, <<=) -DECLOP_1VAR_ASSIGN(uchar1, >>=) - -DECLOP_1VAR_PREOP(uchar1, ++) -DECLOP_1VAR_PREOP(uchar1, --) - -DECLOP_1VAR_POSTOP(uchar1, ++) -DECLOP_1VAR_POSTOP(uchar1, --) - -DECLOP_1VAR_COMP(uchar1, ==) -DECLOP_1VAR_COMP(uchar1, !=) -DECLOP_1VAR_COMP(uchar1, <) -DECLOP_1VAR_COMP(uchar1, >) -DECLOP_1VAR_COMP(uchar1, <=) -DECLOP_1VAR_COMP(uchar1, >=) - -DECLOP_1VAR_COMP(uchar1, &&) -DECLOP_1VAR_COMP(uchar1, ||) - -DECLOP_1VAR_1IN_1OUT(uchar1, ~) -DECLOP_1VAR_1IN_BOOLOUT(uchar1, !) - -DECLOP_1VAR_SCALE_PRODUCT(uchar1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, float) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, double) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, signed long long) - -// UNSIGNED CHAR2 - -DECLOP_2VAR_2IN_1OUT(uchar2, +) -DECLOP_2VAR_2IN_1OUT(uchar2, -) -DECLOP_2VAR_2IN_1OUT(uchar2, *) -DECLOP_2VAR_2IN_1OUT(uchar2, /) -DECLOP_2VAR_2IN_1OUT(uchar2, %) -DECLOP_2VAR_2IN_1OUT(uchar2, &) -DECLOP_2VAR_2IN_1OUT(uchar2, |) -DECLOP_2VAR_2IN_1OUT(uchar2, ^) -DECLOP_2VAR_2IN_1OUT(uchar2, <<) -DECLOP_2VAR_2IN_1OUT(uchar2, >>) - -DECLOP_2VAR_ASSIGN(uchar2, +=) -DECLOP_2VAR_ASSIGN(uchar2, -=) -DECLOP_2VAR_ASSIGN(uchar2, *=) -DECLOP_2VAR_ASSIGN(uchar2, /=) -DECLOP_2VAR_ASSIGN(uchar2, %=) -DECLOP_2VAR_ASSIGN(uchar2, &=) -DECLOP_2VAR_ASSIGN(uchar2, |=) -DECLOP_2VAR_ASSIGN(uchar2, ^=) -DECLOP_2VAR_ASSIGN(uchar2, <<=) -DECLOP_2VAR_ASSIGN(uchar2, >>=) - -DECLOP_2VAR_PREOP(uchar2, ++) -DECLOP_2VAR_PREOP(uchar2, --) - -DECLOP_2VAR_POSTOP(uchar2, ++) -DECLOP_2VAR_POSTOP(uchar2, --) - -DECLOP_2VAR_COMP(uchar2, ==) -DECLOP_2VAR_COMP(uchar2, !=) -DECLOP_2VAR_COMP(uchar2, <) -DECLOP_2VAR_COMP(uchar2, >) -DECLOP_2VAR_COMP(uchar2, <=) -DECLOP_2VAR_COMP(uchar2, >=) - -DECLOP_2VAR_COMP(uchar2, &&) -DECLOP_2VAR_COMP(uchar2, ||) - -DECLOP_2VAR_1IN_1OUT(uchar2, ~) -DECLOP_2VAR_1IN_BOOLOUT(uchar2, !) - -DECLOP_2VAR_SCALE_PRODUCT(uchar2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, float) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, double) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, signed long long) - -// UNSIGNED CHAR3 - -DECLOP_3VAR_2IN_1OUT(uchar3, +) -DECLOP_3VAR_2IN_1OUT(uchar3, -) -DECLOP_3VAR_2IN_1OUT(uchar3, *) -DECLOP_3VAR_2IN_1OUT(uchar3, /) -DECLOP_3VAR_2IN_1OUT(uchar3, %) -DECLOP_3VAR_2IN_1OUT(uchar3, &) -DECLOP_3VAR_2IN_1OUT(uchar3, |) -DECLOP_3VAR_2IN_1OUT(uchar3, ^) -DECLOP_3VAR_2IN_1OUT(uchar3, <<) -DECLOP_3VAR_2IN_1OUT(uchar3, >>) - -DECLOP_3VAR_ASSIGN(uchar3, +=) -DECLOP_3VAR_ASSIGN(uchar3, -=) -DECLOP_3VAR_ASSIGN(uchar3, *=) -DECLOP_3VAR_ASSIGN(uchar3, /=) -DECLOP_3VAR_ASSIGN(uchar3, %=) -DECLOP_3VAR_ASSIGN(uchar3, &=) -DECLOP_3VAR_ASSIGN(uchar3, |=) -DECLOP_3VAR_ASSIGN(uchar3, ^=) -DECLOP_3VAR_ASSIGN(uchar3, <<=) -DECLOP_3VAR_ASSIGN(uchar3, >>=) - -DECLOP_3VAR_PREOP(uchar3, ++) -DECLOP_3VAR_PREOP(uchar3, --) - -DECLOP_3VAR_POSTOP(uchar3, ++) -DECLOP_3VAR_POSTOP(uchar3, --) - -DECLOP_3VAR_COMP(uchar3, ==) -DECLOP_3VAR_COMP(uchar3, !=) -DECLOP_3VAR_COMP(uchar3, <) -DECLOP_3VAR_COMP(uchar3, >) -DECLOP_3VAR_COMP(uchar3, <=) -DECLOP_3VAR_COMP(uchar3, >=) - -DECLOP_3VAR_COMP(uchar3, &&) -DECLOP_3VAR_COMP(uchar3, ||) - -DECLOP_3VAR_1IN_1OUT(uchar3, ~) -DECLOP_3VAR_1IN_BOOLOUT(uchar3, !) - -DECLOP_3VAR_SCALE_PRODUCT(uchar3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, float) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, double) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, signed long long) - -// UNSIGNED CHAR4 - -DECLOP_4VAR_2IN_1OUT(uchar4, +) -DECLOP_4VAR_2IN_1OUT(uchar4, -) -DECLOP_4VAR_2IN_1OUT(uchar4, *) -DECLOP_4VAR_2IN_1OUT(uchar4, /) -DECLOP_4VAR_2IN_1OUT(uchar4, %) -DECLOP_4VAR_2IN_1OUT(uchar4, &) -DECLOP_4VAR_2IN_1OUT(uchar4, |) -DECLOP_4VAR_2IN_1OUT(uchar4, ^) -DECLOP_4VAR_2IN_1OUT(uchar4, <<) -DECLOP_4VAR_2IN_1OUT(uchar4, >>) - -DECLOP_4VAR_ASSIGN(uchar4, +=) -DECLOP_4VAR_ASSIGN(uchar4, -=) -DECLOP_4VAR_ASSIGN(uchar4, *=) -DECLOP_4VAR_ASSIGN(uchar4, /=) -DECLOP_4VAR_ASSIGN(uchar4, %=) -DECLOP_4VAR_ASSIGN(uchar4, &=) -DECLOP_4VAR_ASSIGN(uchar4, |=) -DECLOP_4VAR_ASSIGN(uchar4, ^=) -DECLOP_4VAR_ASSIGN(uchar4, <<=) -DECLOP_4VAR_ASSIGN(uchar4, >>=) - -DECLOP_4VAR_PREOP(uchar4, ++) -DECLOP_4VAR_PREOP(uchar4, --) - -DECLOP_4VAR_POSTOP(uchar4, ++) -DECLOP_4VAR_POSTOP(uchar4, --) - -DECLOP_4VAR_COMP(uchar4, ==) -DECLOP_4VAR_COMP(uchar4, !=) -DECLOP_4VAR_COMP(uchar4, <) -DECLOP_4VAR_COMP(uchar4, >) -DECLOP_4VAR_COMP(uchar4, <=) -DECLOP_4VAR_COMP(uchar4, >=) - -DECLOP_4VAR_COMP(uchar4, &&) -DECLOP_4VAR_COMP(uchar4, ||) - -DECLOP_4VAR_1IN_1OUT(uchar4, ~) -DECLOP_4VAR_1IN_BOOLOUT(uchar4, !) - -DECLOP_4VAR_SCALE_PRODUCT(uchar4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, float) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, double) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, signed long long) - -// SIGNED CHAR1 - -DECLOP_1VAR_2IN_1OUT(char1, +) -DECLOP_1VAR_2IN_1OUT(char1, -) -DECLOP_1VAR_2IN_1OUT(char1, *) -DECLOP_1VAR_2IN_1OUT(char1, /) -DECLOP_1VAR_2IN_1OUT(char1, %) -DECLOP_1VAR_2IN_1OUT(char1, &) -DECLOP_1VAR_2IN_1OUT(char1, |) -DECLOP_1VAR_2IN_1OUT(char1, ^) -DECLOP_1VAR_2IN_1OUT(char1, <<) -DECLOP_1VAR_2IN_1OUT(char1, >>) - - -DECLOP_1VAR_ASSIGN(char1, +=) -DECLOP_1VAR_ASSIGN(char1, -=) -DECLOP_1VAR_ASSIGN(char1, *=) -DECLOP_1VAR_ASSIGN(char1, /=) -DECLOP_1VAR_ASSIGN(char1, %=) -DECLOP_1VAR_ASSIGN(char1, &=) -DECLOP_1VAR_ASSIGN(char1, |=) -DECLOP_1VAR_ASSIGN(char1, ^=) -DECLOP_1VAR_ASSIGN(char1, <<=) -DECLOP_1VAR_ASSIGN(char1, >>=) - -DECLOP_1VAR_PREOP(char1, ++) -DECLOP_1VAR_PREOP(char1, --) - -DECLOP_1VAR_POSTOP(char1, ++) -DECLOP_1VAR_POSTOP(char1, --) - -DECLOP_1VAR_COMP(char1, ==) -DECLOP_1VAR_COMP(char1, !=) -DECLOP_1VAR_COMP(char1, <) -DECLOP_1VAR_COMP(char1, >) -DECLOP_1VAR_COMP(char1, <=) -DECLOP_1VAR_COMP(char1, >=) - -DECLOP_1VAR_COMP(char1, &&) -DECLOP_1VAR_COMP(char1, ||) - -DECLOP_1VAR_1IN_1OUT(char1, ~) -DECLOP_1VAR_1IN_BOOLOUT(char1, !) - -DECLOP_1VAR_SCALE_PRODUCT(char1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(char1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(char1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(char1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(char1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(char1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(char1, float) -DECLOP_1VAR_SCALE_PRODUCT(char1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(char1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(char1, double) -DECLOP_1VAR_SCALE_PRODUCT(char1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(char1, signed long long) - -// SIGNED CHAR2 - -DECLOP_2VAR_2IN_1OUT(char2, +) -DECLOP_2VAR_2IN_1OUT(char2, -) -DECLOP_2VAR_2IN_1OUT(char2, *) -DECLOP_2VAR_2IN_1OUT(char2, /) -DECLOP_2VAR_2IN_1OUT(char2, %) -DECLOP_2VAR_2IN_1OUT(char2, &) -DECLOP_2VAR_2IN_1OUT(char2, |) -DECLOP_2VAR_2IN_1OUT(char2, ^) -DECLOP_2VAR_2IN_1OUT(char2, <<) -DECLOP_2VAR_2IN_1OUT(char2, >>) - -DECLOP_2VAR_ASSIGN(char2, +=) -DECLOP_2VAR_ASSIGN(char2, -=) -DECLOP_2VAR_ASSIGN(char2, *=) -DECLOP_2VAR_ASSIGN(char2, /=) -DECLOP_2VAR_ASSIGN(char2, %=) -DECLOP_2VAR_ASSIGN(char2, &=) -DECLOP_2VAR_ASSIGN(char2, |=) -DECLOP_2VAR_ASSIGN(char2, ^=) -DECLOP_2VAR_ASSIGN(char2, <<=) -DECLOP_2VAR_ASSIGN(char2, >>=) - -DECLOP_2VAR_PREOP(char2, ++) -DECLOP_2VAR_PREOP(char2, --) - -DECLOP_2VAR_POSTOP(char2, ++) -DECLOP_2VAR_POSTOP(char2, --) - -DECLOP_2VAR_COMP(char2, ==) -DECLOP_2VAR_COMP(char2, !=) -DECLOP_2VAR_COMP(char2, <) -DECLOP_2VAR_COMP(char2, >) -DECLOP_2VAR_COMP(char2, <=) -DECLOP_2VAR_COMP(char2, >=) - -DECLOP_2VAR_COMP(char2, &&) -DECLOP_2VAR_COMP(char2, ||) - -DECLOP_2VAR_1IN_1OUT(char2, ~) -DECLOP_2VAR_1IN_BOOLOUT(char2, !) - -DECLOP_2VAR_SCALE_PRODUCT(char2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(char2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(char2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(char2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(char2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(char2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(char2, float) -DECLOP_2VAR_SCALE_PRODUCT(char2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(char2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(char2, double) -DECLOP_2VAR_SCALE_PRODUCT(char2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(char2, signed long long) - -// SIGNED CHAR3 - -DECLOP_3VAR_2IN_1OUT(char3, +) -DECLOP_3VAR_2IN_1OUT(char3, -) -DECLOP_3VAR_2IN_1OUT(char3, *) -DECLOP_3VAR_2IN_1OUT(char3, /) -DECLOP_3VAR_2IN_1OUT(char3, %) -DECLOP_3VAR_2IN_1OUT(char3, &) -DECLOP_3VAR_2IN_1OUT(char3, |) -DECLOP_3VAR_2IN_1OUT(char3, ^) -DECLOP_3VAR_2IN_1OUT(char3, <<) -DECLOP_3VAR_2IN_1OUT(char3, >>) - -DECLOP_3VAR_ASSIGN(char3, +=) -DECLOP_3VAR_ASSIGN(char3, -=) -DECLOP_3VAR_ASSIGN(char3, *=) -DECLOP_3VAR_ASSIGN(char3, /=) -DECLOP_3VAR_ASSIGN(char3, %=) -DECLOP_3VAR_ASSIGN(char3, &=) -DECLOP_3VAR_ASSIGN(char3, |=) -DECLOP_3VAR_ASSIGN(char3, ^=) -DECLOP_3VAR_ASSIGN(char3, <<=) -DECLOP_3VAR_ASSIGN(char3, >>=) - -DECLOP_3VAR_PREOP(char3, ++) -DECLOP_3VAR_PREOP(char3, --) - -DECLOP_3VAR_POSTOP(char3, ++) -DECLOP_3VAR_POSTOP(char3, --) - -DECLOP_3VAR_COMP(char3, ==) -DECLOP_3VAR_COMP(char3, !=) -DECLOP_3VAR_COMP(char3, <) -DECLOP_3VAR_COMP(char3, >) -DECLOP_3VAR_COMP(char3, <=) -DECLOP_3VAR_COMP(char3, >=) - -DECLOP_3VAR_COMP(char3, &&) -DECLOP_3VAR_COMP(char3, ||) - -DECLOP_3VAR_1IN_1OUT(char3, ~) -DECLOP_3VAR_1IN_BOOLOUT(char3, !) - -DECLOP_3VAR_SCALE_PRODUCT(char3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(char3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(char3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(char3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(char3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(char3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(char3, float) -DECLOP_3VAR_SCALE_PRODUCT(char3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(char3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(char3, double) -DECLOP_3VAR_SCALE_PRODUCT(char3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(char3, signed long long) - -// SIGNED CHAR4 - -DECLOP_4VAR_2IN_1OUT(char4, +) -DECLOP_4VAR_2IN_1OUT(char4, -) -DECLOP_4VAR_2IN_1OUT(char4, *) -DECLOP_4VAR_2IN_1OUT(char4, /) -DECLOP_4VAR_2IN_1OUT(char4, %) -DECLOP_4VAR_2IN_1OUT(char4, &) -DECLOP_4VAR_2IN_1OUT(char4, |) -DECLOP_4VAR_2IN_1OUT(char4, ^) -DECLOP_4VAR_2IN_1OUT(char4, <<) -DECLOP_4VAR_2IN_1OUT(char4, >>) - -DECLOP_4VAR_ASSIGN(char4, +=) -DECLOP_4VAR_ASSIGN(char4, -=) -DECLOP_4VAR_ASSIGN(char4, *=) -DECLOP_4VAR_ASSIGN(char4, /=) -DECLOP_4VAR_ASSIGN(char4, %=) -DECLOP_4VAR_ASSIGN(char4, &=) -DECLOP_4VAR_ASSIGN(char4, |=) -DECLOP_4VAR_ASSIGN(char4, ^=) -DECLOP_4VAR_ASSIGN(char4, <<=) -DECLOP_4VAR_ASSIGN(char4, >>=) - -DECLOP_4VAR_PREOP(char4, ++) -DECLOP_4VAR_PREOP(char4, --) - -DECLOP_4VAR_POSTOP(char4, ++) -DECLOP_4VAR_POSTOP(char4, --) - -DECLOP_4VAR_COMP(char4, ==) -DECLOP_4VAR_COMP(char4, !=) -DECLOP_4VAR_COMP(char4, <) -DECLOP_4VAR_COMP(char4, >) -DECLOP_4VAR_COMP(char4, <=) -DECLOP_4VAR_COMP(char4, >=) - -DECLOP_4VAR_COMP(char4, &&) -DECLOP_4VAR_COMP(char4, ||) - -DECLOP_4VAR_1IN_1OUT(char4, ~) -DECLOP_4VAR_1IN_BOOLOUT(char4, !) - -DECLOP_4VAR_SCALE_PRODUCT(char4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(char4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(char4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(char4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(char4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(char4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(char4, float) -DECLOP_4VAR_SCALE_PRODUCT(char4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(char4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(char4, double) -DECLOP_4VAR_SCALE_PRODUCT(char4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(char4, signed long long) - -// UNSIGNED SHORT1 - -DECLOP_1VAR_2IN_1OUT(ushort1, +) -DECLOP_1VAR_2IN_1OUT(ushort1, -) -DECLOP_1VAR_2IN_1OUT(ushort1, *) -DECLOP_1VAR_2IN_1OUT(ushort1, /) -DECLOP_1VAR_2IN_1OUT(ushort1, %) -DECLOP_1VAR_2IN_1OUT(ushort1, &) -DECLOP_1VAR_2IN_1OUT(ushort1, |) -DECLOP_1VAR_2IN_1OUT(ushort1, ^) -DECLOP_1VAR_2IN_1OUT(ushort1, <<) -DECLOP_1VAR_2IN_1OUT(ushort1, >>) - - -DECLOP_1VAR_ASSIGN(ushort1, +=) -DECLOP_1VAR_ASSIGN(ushort1, -=) -DECLOP_1VAR_ASSIGN(ushort1, *=) -DECLOP_1VAR_ASSIGN(ushort1, /=) -DECLOP_1VAR_ASSIGN(ushort1, %=) -DECLOP_1VAR_ASSIGN(ushort1, &=) -DECLOP_1VAR_ASSIGN(ushort1, |=) -DECLOP_1VAR_ASSIGN(ushort1, ^=) -DECLOP_1VAR_ASSIGN(ushort1, <<=) -DECLOP_1VAR_ASSIGN(ushort1, >>=) - -DECLOP_1VAR_PREOP(ushort1, ++) -DECLOP_1VAR_PREOP(ushort1, --) - -DECLOP_1VAR_POSTOP(ushort1, ++) -DECLOP_1VAR_POSTOP(ushort1, --) - -DECLOP_1VAR_COMP(ushort1, ==) -DECLOP_1VAR_COMP(ushort1, !=) -DECLOP_1VAR_COMP(ushort1, <) -DECLOP_1VAR_COMP(ushort1, >) -DECLOP_1VAR_COMP(ushort1, <=) -DECLOP_1VAR_COMP(ushort1, >=) - -DECLOP_1VAR_COMP(ushort1, &&) -DECLOP_1VAR_COMP(ushort1, ||) - -DECLOP_1VAR_1IN_1OUT(ushort1, ~) -DECLOP_1VAR_1IN_BOOLOUT(ushort1, !) - -DECLOP_1VAR_SCALE_PRODUCT(ushort1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, float) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, double) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, signed long long) - -// UNSIGNED SHORT2 - -DECLOP_2VAR_2IN_1OUT(ushort2, +) -DECLOP_2VAR_2IN_1OUT(ushort2, -) -DECLOP_2VAR_2IN_1OUT(ushort2, *) -DECLOP_2VAR_2IN_1OUT(ushort2, /) -DECLOP_2VAR_2IN_1OUT(ushort2, %) -DECLOP_2VAR_2IN_1OUT(ushort2, &) -DECLOP_2VAR_2IN_1OUT(ushort2, |) -DECLOP_2VAR_2IN_1OUT(ushort2, ^) -DECLOP_2VAR_2IN_1OUT(ushort2, <<) -DECLOP_2VAR_2IN_1OUT(ushort2, >>) - -DECLOP_2VAR_ASSIGN(ushort2, +=) -DECLOP_2VAR_ASSIGN(ushort2, -=) -DECLOP_2VAR_ASSIGN(ushort2, *=) -DECLOP_2VAR_ASSIGN(ushort2, /=) -DECLOP_2VAR_ASSIGN(ushort2, %=) -DECLOP_2VAR_ASSIGN(ushort2, &=) -DECLOP_2VAR_ASSIGN(ushort2, |=) -DECLOP_2VAR_ASSIGN(ushort2, ^=) -DECLOP_2VAR_ASSIGN(ushort2, <<=) -DECLOP_2VAR_ASSIGN(ushort2, >>=) - -DECLOP_2VAR_PREOP(ushort2, ++) -DECLOP_2VAR_PREOP(ushort2, --) - -DECLOP_2VAR_POSTOP(ushort2, ++) -DECLOP_2VAR_POSTOP(ushort2, --) - -DECLOP_2VAR_COMP(ushort2, ==) -DECLOP_2VAR_COMP(ushort2, !=) -DECLOP_2VAR_COMP(ushort2, <) -DECLOP_2VAR_COMP(ushort2, >) -DECLOP_2VAR_COMP(ushort2, <=) -DECLOP_2VAR_COMP(ushort2, >=) - -DECLOP_2VAR_COMP(ushort2, &&) -DECLOP_2VAR_COMP(ushort2, ||) - -DECLOP_2VAR_1IN_1OUT(ushort2, ~) -DECLOP_2VAR_1IN_BOOLOUT(ushort2, !) - -DECLOP_2VAR_SCALE_PRODUCT(ushort2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, float) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, double) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, signed long long) - -// UNSIGNED SHORT3 - -DECLOP_3VAR_2IN_1OUT(ushort3, +) -DECLOP_3VAR_2IN_1OUT(ushort3, -) -DECLOP_3VAR_2IN_1OUT(ushort3, *) -DECLOP_3VAR_2IN_1OUT(ushort3, /) -DECLOP_3VAR_2IN_1OUT(ushort3, %) -DECLOP_3VAR_2IN_1OUT(ushort3, &) -DECLOP_3VAR_2IN_1OUT(ushort3, |) -DECLOP_3VAR_2IN_1OUT(ushort3, ^) -DECLOP_3VAR_2IN_1OUT(ushort3, <<) -DECLOP_3VAR_2IN_1OUT(ushort3, >>) - -DECLOP_3VAR_ASSIGN(ushort3, +=) -DECLOP_3VAR_ASSIGN(ushort3, -=) -DECLOP_3VAR_ASSIGN(ushort3, *=) -DECLOP_3VAR_ASSIGN(ushort3, /=) -DECLOP_3VAR_ASSIGN(ushort3, %=) -DECLOP_3VAR_ASSIGN(ushort3, &=) -DECLOP_3VAR_ASSIGN(ushort3, |=) -DECLOP_3VAR_ASSIGN(ushort3, ^=) -DECLOP_3VAR_ASSIGN(ushort3, <<=) -DECLOP_3VAR_ASSIGN(ushort3, >>=) - -DECLOP_3VAR_PREOP(ushort3, ++) -DECLOP_3VAR_PREOP(ushort3, --) - -DECLOP_3VAR_POSTOP(ushort3, ++) -DECLOP_3VAR_POSTOP(ushort3, --) - -DECLOP_3VAR_COMP(ushort3, ==) -DECLOP_3VAR_COMP(ushort3, !=) -DECLOP_3VAR_COMP(ushort3, <) -DECLOP_3VAR_COMP(ushort3, >) -DECLOP_3VAR_COMP(ushort3, <=) -DECLOP_3VAR_COMP(ushort3, >=) - -DECLOP_3VAR_COMP(ushort3, &&) -DECLOP_3VAR_COMP(ushort3, ||) - -DECLOP_3VAR_1IN_1OUT(ushort3, ~) -DECLOP_3VAR_1IN_BOOLOUT(ushort3, !) - -DECLOP_3VAR_SCALE_PRODUCT(ushort3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, float) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, double) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, signed long long) - -// UNSIGNED SHORT4 - -DECLOP_4VAR_2IN_1OUT(ushort4, +) -DECLOP_4VAR_2IN_1OUT(ushort4, -) -DECLOP_4VAR_2IN_1OUT(ushort4, *) -DECLOP_4VAR_2IN_1OUT(ushort4, /) -DECLOP_4VAR_2IN_1OUT(ushort4, %) -DECLOP_4VAR_2IN_1OUT(ushort4, &) -DECLOP_4VAR_2IN_1OUT(ushort4, |) -DECLOP_4VAR_2IN_1OUT(ushort4, ^) -DECLOP_4VAR_2IN_1OUT(ushort4, <<) -DECLOP_4VAR_2IN_1OUT(ushort4, >>) - -DECLOP_4VAR_ASSIGN(ushort4, +=) -DECLOP_4VAR_ASSIGN(ushort4, -=) -DECLOP_4VAR_ASSIGN(ushort4, *=) -DECLOP_4VAR_ASSIGN(ushort4, /=) -DECLOP_4VAR_ASSIGN(ushort4, %=) -DECLOP_4VAR_ASSIGN(ushort4, &=) -DECLOP_4VAR_ASSIGN(ushort4, |=) -DECLOP_4VAR_ASSIGN(ushort4, ^=) -DECLOP_4VAR_ASSIGN(ushort4, <<=) -DECLOP_4VAR_ASSIGN(ushort4, >>=) - -DECLOP_4VAR_PREOP(ushort4, ++) -DECLOP_4VAR_PREOP(ushort4, --) - -DECLOP_4VAR_POSTOP(ushort4, ++) -DECLOP_4VAR_POSTOP(ushort4, --) - -DECLOP_4VAR_COMP(ushort4, ==) -DECLOP_4VAR_COMP(ushort4, !=) -DECLOP_4VAR_COMP(ushort4, <) -DECLOP_4VAR_COMP(ushort4, >) -DECLOP_4VAR_COMP(ushort4, <=) -DECLOP_4VAR_COMP(ushort4, >=) - -DECLOP_4VAR_COMP(ushort4, &&) -DECLOP_4VAR_COMP(ushort4, ||) - -DECLOP_4VAR_1IN_1OUT(ushort4, ~) -DECLOP_4VAR_1IN_BOOLOUT(ushort4, !) - -DECLOP_4VAR_SCALE_PRODUCT(ushort4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, float) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, double) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, signed long long) - -// SIGNED SHORT1 - -DECLOP_1VAR_2IN_1OUT(short1, +) -DECLOP_1VAR_2IN_1OUT(short1, -) -DECLOP_1VAR_2IN_1OUT(short1, *) -DECLOP_1VAR_2IN_1OUT(short1, /) -DECLOP_1VAR_2IN_1OUT(short1, %) -DECLOP_1VAR_2IN_1OUT(short1, &) -DECLOP_1VAR_2IN_1OUT(short1, |) -DECLOP_1VAR_2IN_1OUT(short1, ^) -DECLOP_1VAR_2IN_1OUT(short1, <<) -DECLOP_1VAR_2IN_1OUT(short1, >>) - - -DECLOP_1VAR_ASSIGN(short1, +=) -DECLOP_1VAR_ASSIGN(short1, -=) -DECLOP_1VAR_ASSIGN(short1, *=) -DECLOP_1VAR_ASSIGN(short1, /=) -DECLOP_1VAR_ASSIGN(short1, %=) -DECLOP_1VAR_ASSIGN(short1, &=) -DECLOP_1VAR_ASSIGN(short1, |=) -DECLOP_1VAR_ASSIGN(short1, ^=) -DECLOP_1VAR_ASSIGN(short1, <<=) -DECLOP_1VAR_ASSIGN(short1, >>=) - -DECLOP_1VAR_PREOP(short1, ++) -DECLOP_1VAR_PREOP(short1, --) - -DECLOP_1VAR_POSTOP(short1, ++) -DECLOP_1VAR_POSTOP(short1, --) - -DECLOP_1VAR_COMP(short1, ==) -DECLOP_1VAR_COMP(short1, !=) -DECLOP_1VAR_COMP(short1, <) -DECLOP_1VAR_COMP(short1, >) -DECLOP_1VAR_COMP(short1, <=) -DECLOP_1VAR_COMP(short1, >=) - -DECLOP_1VAR_COMP(short1, &&) -DECLOP_1VAR_COMP(short1, ||) - -DECLOP_1VAR_1IN_1OUT(short1, ~) -DECLOP_1VAR_1IN_BOOLOUT(short1, !) - -DECLOP_1VAR_SCALE_PRODUCT(short1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(short1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(short1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(short1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(short1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(short1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(short1, float) -DECLOP_1VAR_SCALE_PRODUCT(short1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(short1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(short1, double) -DECLOP_1VAR_SCALE_PRODUCT(short1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(short1, signed long long) - -// SIGNED SHORT2 - -DECLOP_2VAR_2IN_1OUT(short2, +) -DECLOP_2VAR_2IN_1OUT(short2, -) -DECLOP_2VAR_2IN_1OUT(short2, *) -DECLOP_2VAR_2IN_1OUT(short2, /) -DECLOP_2VAR_2IN_1OUT(short2, %) -DECLOP_2VAR_2IN_1OUT(short2, &) -DECLOP_2VAR_2IN_1OUT(short2, |) -DECLOP_2VAR_2IN_1OUT(short2, ^) -DECLOP_2VAR_2IN_1OUT(short2, <<) -DECLOP_2VAR_2IN_1OUT(short2, >>) - -DECLOP_2VAR_ASSIGN(short2, +=) -DECLOP_2VAR_ASSIGN(short2, -=) -DECLOP_2VAR_ASSIGN(short2, *=) -DECLOP_2VAR_ASSIGN(short2, /=) -DECLOP_2VAR_ASSIGN(short2, %=) -DECLOP_2VAR_ASSIGN(short2, &=) -DECLOP_2VAR_ASSIGN(short2, |=) -DECLOP_2VAR_ASSIGN(short2, ^=) -DECLOP_2VAR_ASSIGN(short2, <<=) -DECLOP_2VAR_ASSIGN(short2, >>=) - -DECLOP_2VAR_PREOP(short2, ++) -DECLOP_2VAR_PREOP(short2, --) - -DECLOP_2VAR_POSTOP(short2, ++) -DECLOP_2VAR_POSTOP(short2, --) - -DECLOP_2VAR_COMP(short2, ==) -DECLOP_2VAR_COMP(short2, !=) -DECLOP_2VAR_COMP(short2, <) -DECLOP_2VAR_COMP(short2, >) -DECLOP_2VAR_COMP(short2, <=) -DECLOP_2VAR_COMP(short2, >=) - -DECLOP_2VAR_COMP(short2, &&) -DECLOP_2VAR_COMP(short2, ||) - -DECLOP_2VAR_1IN_1OUT(short2, ~) -DECLOP_2VAR_1IN_BOOLOUT(short2, !) - -DECLOP_2VAR_SCALE_PRODUCT(short2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(short2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(short2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(short2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(short2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(short2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(short2, float) -DECLOP_2VAR_SCALE_PRODUCT(short2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(short2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(short2, double) -DECLOP_2VAR_SCALE_PRODUCT(short2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(short2, signed long long) - -// SIGNED SHORT3 - -DECLOP_3VAR_2IN_1OUT(short3, +) -DECLOP_3VAR_2IN_1OUT(short3, -) -DECLOP_3VAR_2IN_1OUT(short3, *) -DECLOP_3VAR_2IN_1OUT(short3, /) -DECLOP_3VAR_2IN_1OUT(short3, %) -DECLOP_3VAR_2IN_1OUT(short3, &) -DECLOP_3VAR_2IN_1OUT(short3, |) -DECLOP_3VAR_2IN_1OUT(short3, ^) -DECLOP_3VAR_2IN_1OUT(short3, <<) -DECLOP_3VAR_2IN_1OUT(short3, >>) - -DECLOP_3VAR_ASSIGN(short3, +=) -DECLOP_3VAR_ASSIGN(short3, -=) -DECLOP_3VAR_ASSIGN(short3, *=) -DECLOP_3VAR_ASSIGN(short3, /=) -DECLOP_3VAR_ASSIGN(short3, %=) -DECLOP_3VAR_ASSIGN(short3, &=) -DECLOP_3VAR_ASSIGN(short3, |=) -DECLOP_3VAR_ASSIGN(short3, ^=) -DECLOP_3VAR_ASSIGN(short3, <<=) -DECLOP_3VAR_ASSIGN(short3, >>=) - -DECLOP_3VAR_PREOP(short3, ++) -DECLOP_3VAR_PREOP(short3, --) - -DECLOP_3VAR_POSTOP(short3, ++) -DECLOP_3VAR_POSTOP(short3, --) - -DECLOP_3VAR_COMP(short3, ==) -DECLOP_3VAR_COMP(short3, !=) -DECLOP_3VAR_COMP(short3, <) -DECLOP_3VAR_COMP(short3, >) -DECLOP_3VAR_COMP(short3, <=) -DECLOP_3VAR_COMP(short3, >=) - -DECLOP_3VAR_COMP(short3, &&) -DECLOP_3VAR_COMP(short3, ||) - -DECLOP_3VAR_1IN_1OUT(short3, ~) -DECLOP_3VAR_1IN_BOOLOUT(short3, !) - -DECLOP_3VAR_SCALE_PRODUCT(short3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(short3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(short3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(short3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(short3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(short3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(short3, float) -DECLOP_3VAR_SCALE_PRODUCT(short3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(short3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(short3, double) -DECLOP_3VAR_SCALE_PRODUCT(short3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(short3, signed long long) - -// SIGNED SHORT4 - -DECLOP_4VAR_2IN_1OUT(short4, +) -DECLOP_4VAR_2IN_1OUT(short4, -) -DECLOP_4VAR_2IN_1OUT(short4, *) -DECLOP_4VAR_2IN_1OUT(short4, /) -DECLOP_4VAR_2IN_1OUT(short4, %) -DECLOP_4VAR_2IN_1OUT(short4, &) -DECLOP_4VAR_2IN_1OUT(short4, |) -DECLOP_4VAR_2IN_1OUT(short4, ^) -DECLOP_4VAR_2IN_1OUT(short4, <<) -DECLOP_4VAR_2IN_1OUT(short4, >>) - -DECLOP_4VAR_ASSIGN(short4, +=) -DECLOP_4VAR_ASSIGN(short4, -=) -DECLOP_4VAR_ASSIGN(short4, *=) -DECLOP_4VAR_ASSIGN(short4, /=) -DECLOP_4VAR_ASSIGN(short4, %=) -DECLOP_4VAR_ASSIGN(short4, &=) -DECLOP_4VAR_ASSIGN(short4, |=) -DECLOP_4VAR_ASSIGN(short4, ^=) -DECLOP_4VAR_ASSIGN(short4, <<=) -DECLOP_4VAR_ASSIGN(short4, >>=) - -DECLOP_4VAR_PREOP(short4, ++) -DECLOP_4VAR_PREOP(short4, --) - -DECLOP_4VAR_POSTOP(short4, ++) -DECLOP_4VAR_POSTOP(short4, --) - -DECLOP_4VAR_COMP(short4, ==) -DECLOP_4VAR_COMP(short4, !=) -DECLOP_4VAR_COMP(short4, <) -DECLOP_4VAR_COMP(short4, >) -DECLOP_4VAR_COMP(short4, <=) -DECLOP_4VAR_COMP(short4, >=) - -DECLOP_4VAR_COMP(short4, &&) -DECLOP_4VAR_COMP(short4, ||) - -DECLOP_4VAR_1IN_1OUT(short4, ~) -DECLOP_4VAR_1IN_BOOLOUT(short4, !) - -DECLOP_4VAR_SCALE_PRODUCT(short4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(short4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(short4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(short4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(short4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(short4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(short4, float) -DECLOP_4VAR_SCALE_PRODUCT(short4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(short4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(short4, double) -DECLOP_4VAR_SCALE_PRODUCT(short4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(short4, signed long long) - -// UNSIGNED INT1 - -DECLOP_1VAR_2IN_1OUT(uint1, +) -DECLOP_1VAR_2IN_1OUT(uint1, -) -DECLOP_1VAR_2IN_1OUT(uint1, *) -DECLOP_1VAR_2IN_1OUT(uint1, /) -DECLOP_1VAR_2IN_1OUT(uint1, %) -DECLOP_1VAR_2IN_1OUT(uint1, &) -DECLOP_1VAR_2IN_1OUT(uint1, |) -DECLOP_1VAR_2IN_1OUT(uint1, ^) -DECLOP_1VAR_2IN_1OUT(uint1, <<) -DECLOP_1VAR_2IN_1OUT(uint1, >>) - - -DECLOP_1VAR_ASSIGN(uint1, +=) -DECLOP_1VAR_ASSIGN(uint1, -=) -DECLOP_1VAR_ASSIGN(uint1, *=) -DECLOP_1VAR_ASSIGN(uint1, /=) -DECLOP_1VAR_ASSIGN(uint1, %=) -DECLOP_1VAR_ASSIGN(uint1, &=) -DECLOP_1VAR_ASSIGN(uint1, |=) -DECLOP_1VAR_ASSIGN(uint1, ^=) -DECLOP_1VAR_ASSIGN(uint1, <<=) -DECLOP_1VAR_ASSIGN(uint1, >>=) - -DECLOP_1VAR_PREOP(uint1, ++) -DECLOP_1VAR_PREOP(uint1, --) - -DECLOP_1VAR_POSTOP(uint1, ++) -DECLOP_1VAR_POSTOP(uint1, --) - -DECLOP_1VAR_COMP(uint1, ==) -DECLOP_1VAR_COMP(uint1, !=) -DECLOP_1VAR_COMP(uint1, <) -DECLOP_1VAR_COMP(uint1, >) -DECLOP_1VAR_COMP(uint1, <=) -DECLOP_1VAR_COMP(uint1, >=) - -DECLOP_1VAR_COMP(uint1, &&) -DECLOP_1VAR_COMP(uint1, ||) - -DECLOP_1VAR_1IN_1OUT(uint1, ~) -DECLOP_1VAR_1IN_BOOLOUT(uint1, !) - -DECLOP_1VAR_SCALE_PRODUCT(uint1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(uint1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(uint1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(uint1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(uint1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(uint1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(uint1, float) -DECLOP_1VAR_SCALE_PRODUCT(uint1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(uint1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(uint1, double) -DECLOP_1VAR_SCALE_PRODUCT(uint1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(uint1, signed long long) - -// UNSIGNED INT2 - -DECLOP_2VAR_2IN_1OUT(uint2, +) -DECLOP_2VAR_2IN_1OUT(uint2, -) -DECLOP_2VAR_2IN_1OUT(uint2, *) -DECLOP_2VAR_2IN_1OUT(uint2, /) -DECLOP_2VAR_2IN_1OUT(uint2, %) -DECLOP_2VAR_2IN_1OUT(uint2, &) -DECLOP_2VAR_2IN_1OUT(uint2, |) -DECLOP_2VAR_2IN_1OUT(uint2, ^) -DECLOP_2VAR_2IN_1OUT(uint2, <<) -DECLOP_2VAR_2IN_1OUT(uint2, >>) - -DECLOP_2VAR_ASSIGN(uint2, +=) -DECLOP_2VAR_ASSIGN(uint2, -=) -DECLOP_2VAR_ASSIGN(uint2, *=) -DECLOP_2VAR_ASSIGN(uint2, /=) -DECLOP_2VAR_ASSIGN(uint2, %=) -DECLOP_2VAR_ASSIGN(uint2, &=) -DECLOP_2VAR_ASSIGN(uint2, |=) -DECLOP_2VAR_ASSIGN(uint2, ^=) -DECLOP_2VAR_ASSIGN(uint2, <<=) -DECLOP_2VAR_ASSIGN(uint2, >>=) - -DECLOP_2VAR_PREOP(uint2, ++) -DECLOP_2VAR_PREOP(uint2, --) - -DECLOP_2VAR_POSTOP(uint2, ++) -DECLOP_2VAR_POSTOP(uint2, --) - -DECLOP_2VAR_COMP(uint2, ==) -DECLOP_2VAR_COMP(uint2, !=) -DECLOP_2VAR_COMP(uint2, <) -DECLOP_2VAR_COMP(uint2, >) -DECLOP_2VAR_COMP(uint2, <=) -DECLOP_2VAR_COMP(uint2, >=) - -DECLOP_2VAR_COMP(uint2, &&) -DECLOP_2VAR_COMP(uint2, ||) - -DECLOP_2VAR_1IN_1OUT(uint2, ~) -DECLOP_2VAR_1IN_BOOLOUT(uint2, !) - -DECLOP_2VAR_SCALE_PRODUCT(uint2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(uint2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(uint2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(uint2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(uint2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(uint2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(uint2, float) -DECLOP_2VAR_SCALE_PRODUCT(uint2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(uint2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(uint2, double) -DECLOP_2VAR_SCALE_PRODUCT(uint2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(uint2, signed long long) - -// UNSIGNED INT3 - -DECLOP_3VAR_2IN_1OUT(uint3, +) -DECLOP_3VAR_2IN_1OUT(uint3, -) -DECLOP_3VAR_2IN_1OUT(uint3, *) -DECLOP_3VAR_2IN_1OUT(uint3, /) -DECLOP_3VAR_2IN_1OUT(uint3, %) -DECLOP_3VAR_2IN_1OUT(uint3, &) -DECLOP_3VAR_2IN_1OUT(uint3, |) -DECLOP_3VAR_2IN_1OUT(uint3, ^) -DECLOP_3VAR_2IN_1OUT(uint3, <<) -DECLOP_3VAR_2IN_1OUT(uint3, >>) - -DECLOP_3VAR_ASSIGN(uint3, +=) -DECLOP_3VAR_ASSIGN(uint3, -=) -DECLOP_3VAR_ASSIGN(uint3, *=) -DECLOP_3VAR_ASSIGN(uint3, /=) -DECLOP_3VAR_ASSIGN(uint3, %=) -DECLOP_3VAR_ASSIGN(uint3, &=) -DECLOP_3VAR_ASSIGN(uint3, |=) -DECLOP_3VAR_ASSIGN(uint3, ^=) -DECLOP_3VAR_ASSIGN(uint3, <<=) -DECLOP_3VAR_ASSIGN(uint3, >>=) - -DECLOP_3VAR_PREOP(uint3, ++) -DECLOP_3VAR_PREOP(uint3, --) - -DECLOP_3VAR_POSTOP(uint3, ++) -DECLOP_3VAR_POSTOP(uint3, --) - -DECLOP_3VAR_COMP(uint3, ==) -DECLOP_3VAR_COMP(uint3, !=) -DECLOP_3VAR_COMP(uint3, <) -DECLOP_3VAR_COMP(uint3, >) -DECLOP_3VAR_COMP(uint3, <=) -DECLOP_3VAR_COMP(uint3, >=) - -DECLOP_3VAR_COMP(uint3, &&) -DECLOP_3VAR_COMP(uint3, ||) - -DECLOP_3VAR_1IN_1OUT(uint3, ~) -DECLOP_3VAR_1IN_BOOLOUT(uint3, !) - -DECLOP_3VAR_SCALE_PRODUCT(uint3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(uint3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(uint3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(uint3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(uint3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(uint3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(uint3, float) -DECLOP_3VAR_SCALE_PRODUCT(uint3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(uint3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(uint3, double) -DECLOP_3VAR_SCALE_PRODUCT(uint3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(uint3, signed long long) - -// UNSIGNED INT4 - -DECLOP_4VAR_2IN_1OUT(uint4, +) -DECLOP_4VAR_2IN_1OUT(uint4, -) -DECLOP_4VAR_2IN_1OUT(uint4, *) -DECLOP_4VAR_2IN_1OUT(uint4, /) -DECLOP_4VAR_2IN_1OUT(uint4, %) -DECLOP_4VAR_2IN_1OUT(uint4, &) -DECLOP_4VAR_2IN_1OUT(uint4, |) -DECLOP_4VAR_2IN_1OUT(uint4, ^) -DECLOP_4VAR_2IN_1OUT(uint4, <<) -DECLOP_4VAR_2IN_1OUT(uint4, >>) - -DECLOP_4VAR_ASSIGN(uint4, +=) -DECLOP_4VAR_ASSIGN(uint4, -=) -DECLOP_4VAR_ASSIGN(uint4, *=) -DECLOP_4VAR_ASSIGN(uint4, /=) -DECLOP_4VAR_ASSIGN(uint4, %=) -DECLOP_4VAR_ASSIGN(uint4, &=) -DECLOP_4VAR_ASSIGN(uint4, |=) -DECLOP_4VAR_ASSIGN(uint4, ^=) -DECLOP_4VAR_ASSIGN(uint4, <<=) -DECLOP_4VAR_ASSIGN(uint4, >>=) - -DECLOP_4VAR_PREOP(uint4, ++) -DECLOP_4VAR_PREOP(uint4, --) - -DECLOP_4VAR_POSTOP(uint4, ++) -DECLOP_4VAR_POSTOP(uint4, --) - -DECLOP_4VAR_COMP(uint4, ==) -DECLOP_4VAR_COMP(uint4, !=) -DECLOP_4VAR_COMP(uint4, <) -DECLOP_4VAR_COMP(uint4, >) -DECLOP_4VAR_COMP(uint4, <=) -DECLOP_4VAR_COMP(uint4, >=) - -DECLOP_4VAR_COMP(uint4, &&) -DECLOP_4VAR_COMP(uint4, ||) - -DECLOP_4VAR_1IN_1OUT(uint4, ~) -DECLOP_4VAR_1IN_BOOLOUT(uint4, !) - -DECLOP_4VAR_SCALE_PRODUCT(uint4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(uint4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(uint4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(uint4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(uint4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(uint4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(uint4, float) -DECLOP_4VAR_SCALE_PRODUCT(uint4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(uint4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(uint4, double) -DECLOP_4VAR_SCALE_PRODUCT(uint4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(uint4, signed long long) - -// SIGNED INT1 - -DECLOP_1VAR_2IN_1OUT(int1, +) -DECLOP_1VAR_2IN_1OUT(int1, -) -DECLOP_1VAR_2IN_1OUT(int1, *) -DECLOP_1VAR_2IN_1OUT(int1, /) -DECLOP_1VAR_2IN_1OUT(int1, %) -DECLOP_1VAR_2IN_1OUT(int1, &) -DECLOP_1VAR_2IN_1OUT(int1, |) -DECLOP_1VAR_2IN_1OUT(int1, ^) -DECLOP_1VAR_2IN_1OUT(int1, <<) -DECLOP_1VAR_2IN_1OUT(int1, >>) - - -DECLOP_1VAR_ASSIGN(int1, +=) -DECLOP_1VAR_ASSIGN(int1, -=) -DECLOP_1VAR_ASSIGN(int1, *=) -DECLOP_1VAR_ASSIGN(int1, /=) -DECLOP_1VAR_ASSIGN(int1, %=) -DECLOP_1VAR_ASSIGN(int1, &=) -DECLOP_1VAR_ASSIGN(int1, |=) -DECLOP_1VAR_ASSIGN(int1, ^=) -DECLOP_1VAR_ASSIGN(int1, <<=) -DECLOP_1VAR_ASSIGN(int1, >>=) - -DECLOP_1VAR_PREOP(int1, ++) -DECLOP_1VAR_PREOP(int1, --) - -DECLOP_1VAR_POSTOP(int1, ++) -DECLOP_1VAR_POSTOP(int1, --) - -DECLOP_1VAR_COMP(int1, ==) -DECLOP_1VAR_COMP(int1, !=) -DECLOP_1VAR_COMP(int1, <) -DECLOP_1VAR_COMP(int1, >) -DECLOP_1VAR_COMP(int1, <=) -DECLOP_1VAR_COMP(int1, >=) - -DECLOP_1VAR_COMP(int1, &&) -DECLOP_1VAR_COMP(int1, ||) - -DECLOP_1VAR_1IN_1OUT(int1, ~) -DECLOP_1VAR_1IN_BOOLOUT(int1, !) - -DECLOP_1VAR_SCALE_PRODUCT(int1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(int1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(int1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(int1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(int1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(int1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(int1, float) -DECLOP_1VAR_SCALE_PRODUCT(int1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(int1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(int1, double) -DECLOP_1VAR_SCALE_PRODUCT(int1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(int1, signed long long) - -// SIGNED INT2 - -DECLOP_2VAR_2IN_1OUT(int2, +) -DECLOP_2VAR_2IN_1OUT(int2, -) -DECLOP_2VAR_2IN_1OUT(int2, *) -DECLOP_2VAR_2IN_1OUT(int2, /) -DECLOP_2VAR_2IN_1OUT(int2, %) -DECLOP_2VAR_2IN_1OUT(int2, &) -DECLOP_2VAR_2IN_1OUT(int2, |) -DECLOP_2VAR_2IN_1OUT(int2, ^) -DECLOP_2VAR_2IN_1OUT(int2, <<) -DECLOP_2VAR_2IN_1OUT(int2, >>) - -DECLOP_2VAR_ASSIGN(int2, +=) -DECLOP_2VAR_ASSIGN(int2, -=) -DECLOP_2VAR_ASSIGN(int2, *=) -DECLOP_2VAR_ASSIGN(int2, /=) -DECLOP_2VAR_ASSIGN(int2, %=) -DECLOP_2VAR_ASSIGN(int2, &=) -DECLOP_2VAR_ASSIGN(int2, |=) -DECLOP_2VAR_ASSIGN(int2, ^=) -DECLOP_2VAR_ASSIGN(int2, <<=) -DECLOP_2VAR_ASSIGN(int2, >>=) - -DECLOP_2VAR_PREOP(int2, ++) -DECLOP_2VAR_PREOP(int2, --) - -DECLOP_2VAR_POSTOP(int2, ++) -DECLOP_2VAR_POSTOP(int2, --) - -DECLOP_2VAR_COMP(int2, ==) -DECLOP_2VAR_COMP(int2, !=) -DECLOP_2VAR_COMP(int2, <) -DECLOP_2VAR_COMP(int2, >) -DECLOP_2VAR_COMP(int2, <=) -DECLOP_2VAR_COMP(int2, >=) - -DECLOP_2VAR_COMP(int2, &&) -DECLOP_2VAR_COMP(int2, ||) - -DECLOP_2VAR_1IN_1OUT(int2, ~) -DECLOP_2VAR_1IN_BOOLOUT(int2, !) - -DECLOP_2VAR_SCALE_PRODUCT(int2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(int2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(int2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(int2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(int2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(int2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(int2, float) -DECLOP_2VAR_SCALE_PRODUCT(int2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(int2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(int2, double) -DECLOP_2VAR_SCALE_PRODUCT(int2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(int2, signed long long) - -// SIGNED INT3 - -DECLOP_3VAR_2IN_1OUT(int3, +) -DECLOP_3VAR_2IN_1OUT(int3, -) -DECLOP_3VAR_2IN_1OUT(int3, *) -DECLOP_3VAR_2IN_1OUT(int3, /) -DECLOP_3VAR_2IN_1OUT(int3, %) -DECLOP_3VAR_2IN_1OUT(int3, &) -DECLOP_3VAR_2IN_1OUT(int3, |) -DECLOP_3VAR_2IN_1OUT(int3, ^) -DECLOP_3VAR_2IN_1OUT(int3, <<) -DECLOP_3VAR_2IN_1OUT(int3, >>) - -DECLOP_3VAR_ASSIGN(int3, +=) -DECLOP_3VAR_ASSIGN(int3, -=) -DECLOP_3VAR_ASSIGN(int3, *=) -DECLOP_3VAR_ASSIGN(int3, /=) -DECLOP_3VAR_ASSIGN(int3, %=) -DECLOP_3VAR_ASSIGN(int3, &=) -DECLOP_3VAR_ASSIGN(int3, |=) -DECLOP_3VAR_ASSIGN(int3, ^=) -DECLOP_3VAR_ASSIGN(int3, <<=) -DECLOP_3VAR_ASSIGN(int3, >>=) - -DECLOP_3VAR_PREOP(int3, ++) -DECLOP_3VAR_PREOP(int3, --) - -DECLOP_3VAR_POSTOP(int3, ++) -DECLOP_3VAR_POSTOP(int3, --) - -DECLOP_3VAR_COMP(int3, ==) -DECLOP_3VAR_COMP(int3, !=) -DECLOP_3VAR_COMP(int3, <) -DECLOP_3VAR_COMP(int3, >) -DECLOP_3VAR_COMP(int3, <=) -DECLOP_3VAR_COMP(int3, >=) - -DECLOP_3VAR_COMP(int3, &&) -DECLOP_3VAR_COMP(int3, ||) - -DECLOP_3VAR_1IN_1OUT(int3, ~) -DECLOP_3VAR_1IN_BOOLOUT(int3, !) - -DECLOP_3VAR_SCALE_PRODUCT(int3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(int3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(int3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(int3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(int3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(int3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(int3, float) -DECLOP_3VAR_SCALE_PRODUCT(int3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(int3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(int3, double) -DECLOP_3VAR_SCALE_PRODUCT(int3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(int3, signed long long) - -// SIGNED INT4 - -DECLOP_4VAR_2IN_1OUT(int4, +) -DECLOP_4VAR_2IN_1OUT(int4, -) -DECLOP_4VAR_2IN_1OUT(int4, *) -DECLOP_4VAR_2IN_1OUT(int4, /) -DECLOP_4VAR_2IN_1OUT(int4, %) -DECLOP_4VAR_2IN_1OUT(int4, &) -DECLOP_4VAR_2IN_1OUT(int4, |) -DECLOP_4VAR_2IN_1OUT(int4, ^) -DECLOP_4VAR_2IN_1OUT(int4, <<) -DECLOP_4VAR_2IN_1OUT(int4, >>) - -DECLOP_4VAR_ASSIGN(int4, +=) -DECLOP_4VAR_ASSIGN(int4, -=) -DECLOP_4VAR_ASSIGN(int4, *=) -DECLOP_4VAR_ASSIGN(int4, /=) -DECLOP_4VAR_ASSIGN(int4, %=) -DECLOP_4VAR_ASSIGN(int4, &=) -DECLOP_4VAR_ASSIGN(int4, |=) -DECLOP_4VAR_ASSIGN(int4, ^=) -DECLOP_4VAR_ASSIGN(int4, <<=) -DECLOP_4VAR_ASSIGN(int4, >>=) - -DECLOP_4VAR_PREOP(int4, ++) -DECLOP_4VAR_PREOP(int4, --) - -DECLOP_4VAR_POSTOP(int4, ++) -DECLOP_4VAR_POSTOP(int4, --) - -DECLOP_4VAR_COMP(int4, ==) -DECLOP_4VAR_COMP(int4, !=) -DECLOP_4VAR_COMP(int4, <) -DECLOP_4VAR_COMP(int4, >) -DECLOP_4VAR_COMP(int4, <=) -DECLOP_4VAR_COMP(int4, >=) - -DECLOP_4VAR_COMP(int4, &&) -DECLOP_4VAR_COMP(int4, ||) - -DECLOP_4VAR_1IN_1OUT(int4, ~) -DECLOP_4VAR_1IN_BOOLOUT(int4, !) - -DECLOP_4VAR_SCALE_PRODUCT(int4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(int4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(int4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(int4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(int4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(int4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(int4, float) -DECLOP_4VAR_SCALE_PRODUCT(int4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(int4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(int4, double) -DECLOP_4VAR_SCALE_PRODUCT(int4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(int4, signed long long) - -// FLOAT1 - -DECLOP_1VAR_2IN_1OUT(float1, +) -DECLOP_1VAR_2IN_1OUT(float1, -) -DECLOP_1VAR_2IN_1OUT(float1, *) -DECLOP_1VAR_2IN_1OUT(float1, /) - -DECLOP_1VAR_ASSIGN(float1, +=) -DECLOP_1VAR_ASSIGN(float1, -=) -DECLOP_1VAR_ASSIGN(float1, *=) -DECLOP_1VAR_ASSIGN(float1, /=) - -DECLOP_1VAR_PREOP(float1, ++) -DECLOP_1VAR_PREOP(float1, --) - -DECLOP_1VAR_POSTOP(float1, ++) -DECLOP_1VAR_POSTOP(float1, --) - -DECLOP_1VAR_COMP(float1, ==) -DECLOP_1VAR_COMP(float1, !=) -DECLOP_1VAR_COMP(float1, <) -DECLOP_1VAR_COMP(float1, >) -DECLOP_1VAR_COMP(float1, <=) -DECLOP_1VAR_COMP(float1, >=) - -DECLOP_1VAR_SCALE_PRODUCT(float1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(float1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(float1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(float1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(float1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(float1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(float1, float) -DECLOP_1VAR_SCALE_PRODUCT(float1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(float1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(float1, double) -DECLOP_1VAR_SCALE_PRODUCT(float1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(float1, signed long long) - -// FLOAT2 - -DECLOP_2VAR_2IN_1OUT(float2, +) -DECLOP_2VAR_2IN_1OUT(float2, -) -DECLOP_2VAR_2IN_1OUT(float2, *) -DECLOP_2VAR_2IN_1OUT(float2, /) - -DECLOP_2VAR_ASSIGN(float2, +=) -DECLOP_2VAR_ASSIGN(float2, -=) -DECLOP_2VAR_ASSIGN(float2, *=) -DECLOP_2VAR_ASSIGN(float2, /=) - -DECLOP_2VAR_PREOP(float2, ++) -DECLOP_2VAR_PREOP(float2, --) - -DECLOP_2VAR_POSTOP(float2, ++) -DECLOP_2VAR_POSTOP(float2, --) - -DECLOP_2VAR_COMP(float2, ==) -DECLOP_2VAR_COMP(float2, !=) -DECLOP_2VAR_COMP(float2, <) -DECLOP_2VAR_COMP(float2, >) -DECLOP_2VAR_COMP(float2, <=) -DECLOP_2VAR_COMP(float2, >=) - -DECLOP_2VAR_SCALE_PRODUCT(float2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(float2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(float2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(float2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(float2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(float2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(float2, float) -DECLOP_2VAR_SCALE_PRODUCT(float2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(float2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(float2, double) -DECLOP_2VAR_SCALE_PRODUCT(float2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(float2, signed long long) - -// FLOAT3 - -DECLOP_3VAR_2IN_1OUT(float3, +) -DECLOP_3VAR_2IN_1OUT(float3, -) -DECLOP_3VAR_2IN_1OUT(float3, *) -DECLOP_3VAR_2IN_1OUT(float3, /) - -DECLOP_3VAR_ASSIGN(float3, +=) -DECLOP_3VAR_ASSIGN(float3, -=) -DECLOP_3VAR_ASSIGN(float3, *=) -DECLOP_3VAR_ASSIGN(float3, /=) - -DECLOP_3VAR_PREOP(float3, ++) -DECLOP_3VAR_PREOP(float3, --) - -DECLOP_3VAR_POSTOP(float3, ++) -DECLOP_3VAR_POSTOP(float3, --) - -DECLOP_3VAR_COMP(float3, ==) -DECLOP_3VAR_COMP(float3, !=) -DECLOP_3VAR_COMP(float3, <) -DECLOP_3VAR_COMP(float3, >) -DECLOP_3VAR_COMP(float3, <=) -DECLOP_3VAR_COMP(float3, >=) - -DECLOP_3VAR_SCALE_PRODUCT(float3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(float3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(float3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(float3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(float3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(float3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(float3, float) -DECLOP_3VAR_SCALE_PRODUCT(float3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(float3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(float3, double) -DECLOP_3VAR_SCALE_PRODUCT(float3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(float3, signed long long) - -// FLOAT4 - -DECLOP_4VAR_2IN_1OUT(float4, +) -DECLOP_4VAR_2IN_1OUT(float4, -) -DECLOP_4VAR_2IN_1OUT(float4, *) -DECLOP_4VAR_2IN_1OUT(float4, /) - -DECLOP_4VAR_ASSIGN(float4, +=) -DECLOP_4VAR_ASSIGN(float4, -=) -DECLOP_4VAR_ASSIGN(float4, *=) -DECLOP_4VAR_ASSIGN(float4, /=) - -DECLOP_4VAR_PREOP(float4, ++) -DECLOP_4VAR_PREOP(float4, --) - -DECLOP_4VAR_POSTOP(float4, ++) -DECLOP_4VAR_POSTOP(float4, --) - -DECLOP_4VAR_COMP(float4, ==) -DECLOP_4VAR_COMP(float4, !=) -DECLOP_4VAR_COMP(float4, <) -DECLOP_4VAR_COMP(float4, >) -DECLOP_4VAR_COMP(float4, <=) -DECLOP_4VAR_COMP(float4, >=) - -DECLOP_4VAR_SCALE_PRODUCT(float4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(float4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(float4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(float4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(float4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(float4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(float4, float) -DECLOP_4VAR_SCALE_PRODUCT(float4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(float4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(float4, double) -DECLOP_4VAR_SCALE_PRODUCT(float4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(float4, signed long long) - -// DOUBLE1 - -DECLOP_1VAR_2IN_1OUT(double1, +) -DECLOP_1VAR_2IN_1OUT(double1, -) -DECLOP_1VAR_2IN_1OUT(double1, *) -DECLOP_1VAR_2IN_1OUT(double1, /) - -DECLOP_1VAR_ASSIGN(double1, +=) -DECLOP_1VAR_ASSIGN(double1, -=) -DECLOP_1VAR_ASSIGN(double1, *=) -DECLOP_1VAR_ASSIGN(double1, /=) - -DECLOP_1VAR_PREOP(double1, ++) -DECLOP_1VAR_PREOP(double1, --) - -DECLOP_1VAR_POSTOP(double1, ++) -DECLOP_1VAR_POSTOP(double1, --) - -DECLOP_1VAR_COMP(double1, ==) -DECLOP_1VAR_COMP(double1, !=) -DECLOP_1VAR_COMP(double1, <) -DECLOP_1VAR_COMP(double1, >) -DECLOP_1VAR_COMP(double1, <=) -DECLOP_1VAR_COMP(double1, >=) - -DECLOP_1VAR_SCALE_PRODUCT(double1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(double1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(double1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(double1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(double1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(double1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(double1, float) -DECLOP_1VAR_SCALE_PRODUCT(double1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(double1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(double1, double) -DECLOP_1VAR_SCALE_PRODUCT(double1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(double1, signed long long) - -// DOUBLE2 - -DECLOP_2VAR_2IN_1OUT(double2, +) -DECLOP_2VAR_2IN_1OUT(double2, -) -DECLOP_2VAR_2IN_1OUT(double2, *) -DECLOP_2VAR_2IN_1OUT(double2, /) - -DECLOP_2VAR_ASSIGN(double2, +=) -DECLOP_2VAR_ASSIGN(double2, -=) -DECLOP_2VAR_ASSIGN(double2, *=) -DECLOP_2VAR_ASSIGN(double2, /=) - -DECLOP_2VAR_PREOP(double2, ++) -DECLOP_2VAR_PREOP(double2, --) - -DECLOP_2VAR_POSTOP(double2, ++) -DECLOP_2VAR_POSTOP(double2, --) - -DECLOP_2VAR_COMP(double2, ==) -DECLOP_2VAR_COMP(double2, !=) -DECLOP_2VAR_COMP(double2, <) -DECLOP_2VAR_COMP(double2, >) -DECLOP_2VAR_COMP(double2, <=) -DECLOP_2VAR_COMP(double2, >=) - -DECLOP_2VAR_SCALE_PRODUCT(double2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(double2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(double2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(double2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(double2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(double2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(double2, float) -DECLOP_2VAR_SCALE_PRODUCT(double2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(double2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(double2, double) -DECLOP_2VAR_SCALE_PRODUCT(double2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(double2, signed long long) - -// DOUBLE3 - -DECLOP_3VAR_2IN_1OUT(double3, +) -DECLOP_3VAR_2IN_1OUT(double3, -) -DECLOP_3VAR_2IN_1OUT(double3, *) -DECLOP_3VAR_2IN_1OUT(double3, /) - -DECLOP_3VAR_ASSIGN(double3, +=) -DECLOP_3VAR_ASSIGN(double3, -=) -DECLOP_3VAR_ASSIGN(double3, *=) -DECLOP_3VAR_ASSIGN(double3, /=) - -DECLOP_3VAR_PREOP(double3, ++) -DECLOP_3VAR_PREOP(double3, --) - -DECLOP_3VAR_POSTOP(double3, ++) -DECLOP_3VAR_POSTOP(double3, --) - -DECLOP_3VAR_COMP(double3, ==) -DECLOP_3VAR_COMP(double3, !=) -DECLOP_3VAR_COMP(double3, <) -DECLOP_3VAR_COMP(double3, >) -DECLOP_3VAR_COMP(double3, <=) -DECLOP_3VAR_COMP(double3, >=) - -DECLOP_3VAR_SCALE_PRODUCT(double3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(double3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(double3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(double3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(double3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(double3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(double3, float) -DECLOP_3VAR_SCALE_PRODUCT(double3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(double3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(double3, double) -DECLOP_3VAR_SCALE_PRODUCT(double3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(double3, signed long long) - -// DOUBLE4 - -DECLOP_4VAR_2IN_1OUT(double4, +) -DECLOP_4VAR_2IN_1OUT(double4, -) -DECLOP_4VAR_2IN_1OUT(double4, *) -DECLOP_4VAR_2IN_1OUT(double4, /) - -DECLOP_4VAR_ASSIGN(double4, +=) -DECLOP_4VAR_ASSIGN(double4, -=) -DECLOP_4VAR_ASSIGN(double4, *=) -DECLOP_4VAR_ASSIGN(double4, /=) - -DECLOP_4VAR_PREOP(double4, ++) -DECLOP_4VAR_PREOP(double4, --) - -DECLOP_4VAR_POSTOP(double4, ++) -DECLOP_4VAR_POSTOP(double4, --) - -DECLOP_4VAR_COMP(double4, ==) -DECLOP_4VAR_COMP(double4, !=) -DECLOP_4VAR_COMP(double4, <) -DECLOP_4VAR_COMP(double4, >) -DECLOP_4VAR_COMP(double4, <=) -DECLOP_4VAR_COMP(double4, >=) - -DECLOP_4VAR_SCALE_PRODUCT(double4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(double4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(double4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(double4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(double4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(double4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(double4, float) -DECLOP_4VAR_SCALE_PRODUCT(double4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(double4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(double4, double) -DECLOP_4VAR_SCALE_PRODUCT(double4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(double4, signed long long) - -// UNSIGNED LONG1 - -DECLOP_1VAR_2IN_1OUT(ulong1, +) -DECLOP_1VAR_2IN_1OUT(ulong1, -) -DECLOP_1VAR_2IN_1OUT(ulong1, *) -DECLOP_1VAR_2IN_1OUT(ulong1, /) -DECLOP_1VAR_2IN_1OUT(ulong1, %) -DECLOP_1VAR_2IN_1OUT(ulong1, &) -DECLOP_1VAR_2IN_1OUT(ulong1, |) -DECLOP_1VAR_2IN_1OUT(ulong1, ^) -DECLOP_1VAR_2IN_1OUT(ulong1, <<) -DECLOP_1VAR_2IN_1OUT(ulong1, >>) - - -DECLOP_1VAR_ASSIGN(ulong1, +=) -DECLOP_1VAR_ASSIGN(ulong1, -=) -DECLOP_1VAR_ASSIGN(ulong1, *=) -DECLOP_1VAR_ASSIGN(ulong1, /=) -DECLOP_1VAR_ASSIGN(ulong1, %=) -DECLOP_1VAR_ASSIGN(ulong1, &=) -DECLOP_1VAR_ASSIGN(ulong1, |=) -DECLOP_1VAR_ASSIGN(ulong1, ^=) -DECLOP_1VAR_ASSIGN(ulong1, <<=) -DECLOP_1VAR_ASSIGN(ulong1, >>=) - -DECLOP_1VAR_PREOP(ulong1, ++) -DECLOP_1VAR_PREOP(ulong1, --) - -DECLOP_1VAR_POSTOP(ulong1, ++) -DECLOP_1VAR_POSTOP(ulong1, --) - -DECLOP_1VAR_COMP(ulong1, ==) -DECLOP_1VAR_COMP(ulong1, !=) -DECLOP_1VAR_COMP(ulong1, <) -DECLOP_1VAR_COMP(ulong1, >) -DECLOP_1VAR_COMP(ulong1, <=) -DECLOP_1VAR_COMP(ulong1, >=) - -DECLOP_1VAR_COMP(ulong1, &&) -DECLOP_1VAR_COMP(ulong1, ||) - -DECLOP_1VAR_1IN_1OUT(ulong1, ~) -DECLOP_1VAR_1IN_BOOLOUT(ulong1, !) - -DECLOP_1VAR_SCALE_PRODUCT(ulong1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, float) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, double) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, signed long long) - -// UNSIGNED LONG2 - -DECLOP_2VAR_2IN_1OUT(ulong2, +) -DECLOP_2VAR_2IN_1OUT(ulong2, -) -DECLOP_2VAR_2IN_1OUT(ulong2, *) -DECLOP_2VAR_2IN_1OUT(ulong2, /) -DECLOP_2VAR_2IN_1OUT(ulong2, %) -DECLOP_2VAR_2IN_1OUT(ulong2, &) -DECLOP_2VAR_2IN_1OUT(ulong2, |) -DECLOP_2VAR_2IN_1OUT(ulong2, ^) -DECLOP_2VAR_2IN_1OUT(ulong2, <<) -DECLOP_2VAR_2IN_1OUT(ulong2, >>) - -DECLOP_2VAR_ASSIGN(ulong2, +=) -DECLOP_2VAR_ASSIGN(ulong2, -=) -DECLOP_2VAR_ASSIGN(ulong2, *=) -DECLOP_2VAR_ASSIGN(ulong2, /=) -DECLOP_2VAR_ASSIGN(ulong2, %=) -DECLOP_2VAR_ASSIGN(ulong2, &=) -DECLOP_2VAR_ASSIGN(ulong2, |=) -DECLOP_2VAR_ASSIGN(ulong2, ^=) -DECLOP_2VAR_ASSIGN(ulong2, <<=) -DECLOP_2VAR_ASSIGN(ulong2, >>=) - -DECLOP_2VAR_PREOP(ulong2, ++) -DECLOP_2VAR_PREOP(ulong2, --) - -DECLOP_2VAR_POSTOP(ulong2, ++) -DECLOP_2VAR_POSTOP(ulong2, --) - -DECLOP_2VAR_COMP(ulong2, ==) -DECLOP_2VAR_COMP(ulong2, !=) -DECLOP_2VAR_COMP(ulong2, <) -DECLOP_2VAR_COMP(ulong2, >) -DECLOP_2VAR_COMP(ulong2, <=) -DECLOP_2VAR_COMP(ulong2, >=) - -DECLOP_2VAR_COMP(ulong2, &&) -DECLOP_2VAR_COMP(ulong2, ||) - -DECLOP_2VAR_1IN_1OUT(ulong2, ~) -DECLOP_2VAR_1IN_BOOLOUT(ulong2, !) - -DECLOP_2VAR_SCALE_PRODUCT(ulong2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, float) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, double) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, signed long long) - -// UNSIGNED LONG3 - -DECLOP_3VAR_2IN_1OUT(ulong3, +) -DECLOP_3VAR_2IN_1OUT(ulong3, -) -DECLOP_3VAR_2IN_1OUT(ulong3, *) -DECLOP_3VAR_2IN_1OUT(ulong3, /) -DECLOP_3VAR_2IN_1OUT(ulong3, %) -DECLOP_3VAR_2IN_1OUT(ulong3, &) -DECLOP_3VAR_2IN_1OUT(ulong3, |) -DECLOP_3VAR_2IN_1OUT(ulong3, ^) -DECLOP_3VAR_2IN_1OUT(ulong3, <<) -DECLOP_3VAR_2IN_1OUT(ulong3, >>) - -DECLOP_3VAR_ASSIGN(ulong3, +=) -DECLOP_3VAR_ASSIGN(ulong3, -=) -DECLOP_3VAR_ASSIGN(ulong3, *=) -DECLOP_3VAR_ASSIGN(ulong3, /=) -DECLOP_3VAR_ASSIGN(ulong3, %=) -DECLOP_3VAR_ASSIGN(ulong3, &=) -DECLOP_3VAR_ASSIGN(ulong3, |=) -DECLOP_3VAR_ASSIGN(ulong3, ^=) -DECLOP_3VAR_ASSIGN(ulong3, <<=) -DECLOP_3VAR_ASSIGN(ulong3, >>=) - -DECLOP_3VAR_PREOP(ulong3, ++) -DECLOP_3VAR_PREOP(ulong3, --) - -DECLOP_3VAR_POSTOP(ulong3, ++) -DECLOP_3VAR_POSTOP(ulong3, --) - -DECLOP_3VAR_COMP(ulong3, ==) -DECLOP_3VAR_COMP(ulong3, !=) -DECLOP_3VAR_COMP(ulong3, <) -DECLOP_3VAR_COMP(ulong3, >) -DECLOP_3VAR_COMP(ulong3, <=) -DECLOP_3VAR_COMP(ulong3, >=) - -DECLOP_3VAR_COMP(ulong3, &&) -DECLOP_3VAR_COMP(ulong3, ||) - -DECLOP_3VAR_1IN_1OUT(ulong3, ~) -DECLOP_3VAR_1IN_BOOLOUT(ulong3, !) - -DECLOP_3VAR_SCALE_PRODUCT(ulong3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, float) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, double) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, signed long long) - -// UNSIGNED LONG4 - -DECLOP_4VAR_2IN_1OUT(ulong4, +) -DECLOP_4VAR_2IN_1OUT(ulong4, -) -DECLOP_4VAR_2IN_1OUT(ulong4, *) -DECLOP_4VAR_2IN_1OUT(ulong4, /) -DECLOP_4VAR_2IN_1OUT(ulong4, %) -DECLOP_4VAR_2IN_1OUT(ulong4, &) -DECLOP_4VAR_2IN_1OUT(ulong4, |) -DECLOP_4VAR_2IN_1OUT(ulong4, ^) -DECLOP_4VAR_2IN_1OUT(ulong4, <<) -DECLOP_4VAR_2IN_1OUT(ulong4, >>) - -DECLOP_4VAR_ASSIGN(ulong4, +=) -DECLOP_4VAR_ASSIGN(ulong4, -=) -DECLOP_4VAR_ASSIGN(ulong4, *=) -DECLOP_4VAR_ASSIGN(ulong4, /=) -DECLOP_4VAR_ASSIGN(ulong4, %=) -DECLOP_4VAR_ASSIGN(ulong4, &=) -DECLOP_4VAR_ASSIGN(ulong4, |=) -DECLOP_4VAR_ASSIGN(ulong4, ^=) -DECLOP_4VAR_ASSIGN(ulong4, <<=) -DECLOP_4VAR_ASSIGN(ulong4, >>=) - -DECLOP_4VAR_PREOP(ulong4, ++) -DECLOP_4VAR_PREOP(ulong4, --) - -DECLOP_4VAR_POSTOP(ulong4, ++) -DECLOP_4VAR_POSTOP(ulong4, --) - -DECLOP_4VAR_COMP(ulong4, ==) -DECLOP_4VAR_COMP(ulong4, !=) -DECLOP_4VAR_COMP(ulong4, <) -DECLOP_4VAR_COMP(ulong4, >) -DECLOP_4VAR_COMP(ulong4, <=) -DECLOP_4VAR_COMP(ulong4, >=) - -DECLOP_4VAR_COMP(ulong4, &&) -DECLOP_4VAR_COMP(ulong4, ||) - -DECLOP_4VAR_1IN_1OUT(ulong4, ~) -DECLOP_4VAR_1IN_BOOLOUT(ulong4, !) - -DECLOP_4VAR_SCALE_PRODUCT(ulong4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, float) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, double) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, signed long long) - -// SIGNED LONG1 - -DECLOP_1VAR_2IN_1OUT(long1, +) -DECLOP_1VAR_2IN_1OUT(long1, -) -DECLOP_1VAR_2IN_1OUT(long1, *) -DECLOP_1VAR_2IN_1OUT(long1, /) -DECLOP_1VAR_2IN_1OUT(long1, %) -DECLOP_1VAR_2IN_1OUT(long1, &) -DECLOP_1VAR_2IN_1OUT(long1, |) -DECLOP_1VAR_2IN_1OUT(long1, ^) -DECLOP_1VAR_2IN_1OUT(long1, <<) -DECLOP_1VAR_2IN_1OUT(long1, >>) - - -DECLOP_1VAR_ASSIGN(long1, +=) -DECLOP_1VAR_ASSIGN(long1, -=) -DECLOP_1VAR_ASSIGN(long1, *=) -DECLOP_1VAR_ASSIGN(long1, /=) -DECLOP_1VAR_ASSIGN(long1, %=) -DECLOP_1VAR_ASSIGN(long1, &=) -DECLOP_1VAR_ASSIGN(long1, |=) -DECLOP_1VAR_ASSIGN(long1, ^=) -DECLOP_1VAR_ASSIGN(long1, <<=) -DECLOP_1VAR_ASSIGN(long1, >>=) - -DECLOP_1VAR_PREOP(long1, ++) -DECLOP_1VAR_PREOP(long1, --) - -DECLOP_1VAR_POSTOP(long1, ++) -DECLOP_1VAR_POSTOP(long1, --) - -DECLOP_1VAR_COMP(long1, ==) -DECLOP_1VAR_COMP(long1, !=) -DECLOP_1VAR_COMP(long1, <) -DECLOP_1VAR_COMP(long1, >) -DECLOP_1VAR_COMP(long1, <=) -DECLOP_1VAR_COMP(long1, >=) - -DECLOP_1VAR_COMP(long1, &&) -DECLOP_1VAR_COMP(long1, ||) - -DECLOP_1VAR_1IN_1OUT(long1, ~) -DECLOP_1VAR_1IN_BOOLOUT(long1, !) - -DECLOP_1VAR_SCALE_PRODUCT(long1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(long1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(long1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(long1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(long1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(long1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(long1, float) -DECLOP_1VAR_SCALE_PRODUCT(long1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(long1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(long1, double) -DECLOP_1VAR_SCALE_PRODUCT(long1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(long1, signed long long) - -// SIGNED LONG2 - -DECLOP_2VAR_2IN_1OUT(long2, +) -DECLOP_2VAR_2IN_1OUT(long2, -) -DECLOP_2VAR_2IN_1OUT(long2, *) -DECLOP_2VAR_2IN_1OUT(long2, /) -DECLOP_2VAR_2IN_1OUT(long2, %) -DECLOP_2VAR_2IN_1OUT(long2, &) -DECLOP_2VAR_2IN_1OUT(long2, |) -DECLOP_2VAR_2IN_1OUT(long2, ^) -DECLOP_2VAR_2IN_1OUT(long2, <<) -DECLOP_2VAR_2IN_1OUT(long2, >>) - -DECLOP_2VAR_ASSIGN(long2, +=) -DECLOP_2VAR_ASSIGN(long2, -=) -DECLOP_2VAR_ASSIGN(long2, *=) -DECLOP_2VAR_ASSIGN(long2, /=) -DECLOP_2VAR_ASSIGN(long2, %=) -DECLOP_2VAR_ASSIGN(long2, &=) -DECLOP_2VAR_ASSIGN(long2, |=) -DECLOP_2VAR_ASSIGN(long2, ^=) -DECLOP_2VAR_ASSIGN(long2, <<=) -DECLOP_2VAR_ASSIGN(long2, >>=) - -DECLOP_2VAR_PREOP(long2, ++) -DECLOP_2VAR_PREOP(long2, --) - -DECLOP_2VAR_POSTOP(long2, ++) -DECLOP_2VAR_POSTOP(long2, --) - -DECLOP_2VAR_COMP(long2, ==) -DECLOP_2VAR_COMP(long2, !=) -DECLOP_2VAR_COMP(long2, <) -DECLOP_2VAR_COMP(long2, >) -DECLOP_2VAR_COMP(long2, <=) -DECLOP_2VAR_COMP(long2, >=) - -DECLOP_2VAR_COMP(long2, &&) -DECLOP_2VAR_COMP(long2, ||) - -DECLOP_2VAR_1IN_1OUT(long2, ~) -DECLOP_2VAR_1IN_BOOLOUT(long2, !) - -DECLOP_2VAR_SCALE_PRODUCT(long2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(long2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(long2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(long2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(long2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(long2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(long2, float) -DECLOP_2VAR_SCALE_PRODUCT(long2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(long2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(long2, double) -DECLOP_2VAR_SCALE_PRODUCT(long2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(long2, signed long long) - -// SIGNED LONG3 - -DECLOP_3VAR_2IN_1OUT(long3, +) -DECLOP_3VAR_2IN_1OUT(long3, -) -DECLOP_3VAR_2IN_1OUT(long3, *) -DECLOP_3VAR_2IN_1OUT(long3, /) -DECLOP_3VAR_2IN_1OUT(long3, %) -DECLOP_3VAR_2IN_1OUT(long3, &) -DECLOP_3VAR_2IN_1OUT(long3, |) -DECLOP_3VAR_2IN_1OUT(long3, ^) -DECLOP_3VAR_2IN_1OUT(long3, <<) -DECLOP_3VAR_2IN_1OUT(long3, >>) - -DECLOP_3VAR_ASSIGN(long3, +=) -DECLOP_3VAR_ASSIGN(long3, -=) -DECLOP_3VAR_ASSIGN(long3, *=) -DECLOP_3VAR_ASSIGN(long3, /=) -DECLOP_3VAR_ASSIGN(long3, %=) -DECLOP_3VAR_ASSIGN(long3, &=) -DECLOP_3VAR_ASSIGN(long3, |=) -DECLOP_3VAR_ASSIGN(long3, ^=) -DECLOP_3VAR_ASSIGN(long3, <<=) -DECLOP_3VAR_ASSIGN(long3, >>=) - -DECLOP_3VAR_PREOP(long3, ++) -DECLOP_3VAR_PREOP(long3, --) - -DECLOP_3VAR_POSTOP(long3, ++) -DECLOP_3VAR_POSTOP(long3, --) - -DECLOP_3VAR_COMP(long3, ==) -DECLOP_3VAR_COMP(long3, !=) -DECLOP_3VAR_COMP(long3, <) -DECLOP_3VAR_COMP(long3, >) -DECLOP_3VAR_COMP(long3, <=) -DECLOP_3VAR_COMP(long3, >=) - -DECLOP_3VAR_COMP(long3, &&) -DECLOP_3VAR_COMP(long3, ||) - -DECLOP_3VAR_1IN_1OUT(long3, ~) -DECLOP_3VAR_1IN_BOOLOUT(long3, !) - -DECLOP_3VAR_SCALE_PRODUCT(long3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(long3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(long3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(long3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(long3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(long3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(long3, float) -DECLOP_3VAR_SCALE_PRODUCT(long3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(long3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(long3, double) -DECLOP_3VAR_SCALE_PRODUCT(long3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(long3, signed long long) - -// SIGNED LONG4 - -DECLOP_4VAR_2IN_1OUT(long4, +) -DECLOP_4VAR_2IN_1OUT(long4, -) -DECLOP_4VAR_2IN_1OUT(long4, *) -DECLOP_4VAR_2IN_1OUT(long4, /) -DECLOP_4VAR_2IN_1OUT(long4, %) -DECLOP_4VAR_2IN_1OUT(long4, &) -DECLOP_4VAR_2IN_1OUT(long4, |) -DECLOP_4VAR_2IN_1OUT(long4, ^) -DECLOP_4VAR_2IN_1OUT(long4, <<) -DECLOP_4VAR_2IN_1OUT(long4, >>) - -DECLOP_4VAR_ASSIGN(long4, +=) -DECLOP_4VAR_ASSIGN(long4, -=) -DECLOP_4VAR_ASSIGN(long4, *=) -DECLOP_4VAR_ASSIGN(long4, /=) -DECLOP_4VAR_ASSIGN(long4, %=) -DECLOP_4VAR_ASSIGN(long4, &=) -DECLOP_4VAR_ASSIGN(long4, |=) -DECLOP_4VAR_ASSIGN(long4, ^=) -DECLOP_4VAR_ASSIGN(long4, <<=) -DECLOP_4VAR_ASSIGN(long4, >>=) - -DECLOP_4VAR_PREOP(long4, ++) -DECLOP_4VAR_PREOP(long4, --) - -DECLOP_4VAR_POSTOP(long4, ++) -DECLOP_4VAR_POSTOP(long4, --) - -DECLOP_4VAR_COMP(long4, ==) -DECLOP_4VAR_COMP(long4, !=) -DECLOP_4VAR_COMP(long4, <) -DECLOP_4VAR_COMP(long4, >) -DECLOP_4VAR_COMP(long4, <=) -DECLOP_4VAR_COMP(long4, >=) - -DECLOP_4VAR_COMP(long4, &&) -DECLOP_4VAR_COMP(long4, ||) - -DECLOP_4VAR_1IN_1OUT(long4, ~) -DECLOP_4VAR_1IN_BOOLOUT(long4, !) - -DECLOP_4VAR_SCALE_PRODUCT(long4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(long4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(long4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(long4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(long4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(long4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(long4, float) -DECLOP_4VAR_SCALE_PRODUCT(long4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(long4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(long4, double) -DECLOP_4VAR_SCALE_PRODUCT(long4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(long4, signed long long) - -// UNSIGNED LONGLONG1 - -DECLOP_1VAR_2IN_1OUT(ulonglong1, +) -DECLOP_1VAR_2IN_1OUT(ulonglong1, -) -DECLOP_1VAR_2IN_1OUT(ulonglong1, *) -DECLOP_1VAR_2IN_1OUT(ulonglong1, /) -DECLOP_1VAR_2IN_1OUT(ulonglong1, %) -DECLOP_1VAR_2IN_1OUT(ulonglong1, &) -DECLOP_1VAR_2IN_1OUT(ulonglong1, |) -DECLOP_1VAR_2IN_1OUT(ulonglong1, ^) -DECLOP_1VAR_2IN_1OUT(ulonglong1, <<) -DECLOP_1VAR_2IN_1OUT(ulonglong1, >>) - - -DECLOP_1VAR_ASSIGN(ulonglong1, +=) -DECLOP_1VAR_ASSIGN(ulonglong1, -=) -DECLOP_1VAR_ASSIGN(ulonglong1, *=) -DECLOP_1VAR_ASSIGN(ulonglong1, /=) -DECLOP_1VAR_ASSIGN(ulonglong1, %=) -DECLOP_1VAR_ASSIGN(ulonglong1, &=) -DECLOP_1VAR_ASSIGN(ulonglong1, |=) -DECLOP_1VAR_ASSIGN(ulonglong1, ^=) -DECLOP_1VAR_ASSIGN(ulonglong1, <<=) -DECLOP_1VAR_ASSIGN(ulonglong1, >>=) - -DECLOP_1VAR_PREOP(ulonglong1, ++) -DECLOP_1VAR_PREOP(ulonglong1, --) - -DECLOP_1VAR_POSTOP(ulonglong1, ++) -DECLOP_1VAR_POSTOP(ulonglong1, --) - -DECLOP_1VAR_COMP(ulonglong1, ==) -DECLOP_1VAR_COMP(ulonglong1, !=) -DECLOP_1VAR_COMP(ulonglong1, <) -DECLOP_1VAR_COMP(ulonglong1, >) -DECLOP_1VAR_COMP(ulonglong1, <=) -DECLOP_1VAR_COMP(ulonglong1, >=) - -DECLOP_1VAR_COMP(ulonglong1, &&) -DECLOP_1VAR_COMP(ulonglong1, ||) - -DECLOP_1VAR_1IN_1OUT(ulonglong1, ~) -DECLOP_1VAR_1IN_BOOLOUT(ulonglong1, !) - -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, float) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, double) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, signed long long) - -// UNSIGNED LONGLONG2 - -DECLOP_2VAR_2IN_1OUT(ulonglong2, +) -DECLOP_2VAR_2IN_1OUT(ulonglong2, -) -DECLOP_2VAR_2IN_1OUT(ulonglong2, *) -DECLOP_2VAR_2IN_1OUT(ulonglong2, /) -DECLOP_2VAR_2IN_1OUT(ulonglong2, %) -DECLOP_2VAR_2IN_1OUT(ulonglong2, &) -DECLOP_2VAR_2IN_1OUT(ulonglong2, |) -DECLOP_2VAR_2IN_1OUT(ulonglong2, ^) -DECLOP_2VAR_2IN_1OUT(ulonglong2, <<) -DECLOP_2VAR_2IN_1OUT(ulonglong2, >>) - -DECLOP_2VAR_ASSIGN(ulonglong2, +=) -DECLOP_2VAR_ASSIGN(ulonglong2, -=) -DECLOP_2VAR_ASSIGN(ulonglong2, *=) -DECLOP_2VAR_ASSIGN(ulonglong2, /=) -DECLOP_2VAR_ASSIGN(ulonglong2, %=) -DECLOP_2VAR_ASSIGN(ulonglong2, &=) -DECLOP_2VAR_ASSIGN(ulonglong2, |=) -DECLOP_2VAR_ASSIGN(ulonglong2, ^=) -DECLOP_2VAR_ASSIGN(ulonglong2, <<=) -DECLOP_2VAR_ASSIGN(ulonglong2, >>=) - -DECLOP_2VAR_PREOP(ulonglong2, ++) -DECLOP_2VAR_PREOP(ulonglong2, --) - -DECLOP_2VAR_POSTOP(ulonglong2, ++) -DECLOP_2VAR_POSTOP(ulonglong2, --) - -DECLOP_2VAR_COMP(ulonglong2, ==) -DECLOP_2VAR_COMP(ulonglong2, !=) -DECLOP_2VAR_COMP(ulonglong2, <) -DECLOP_2VAR_COMP(ulonglong2, >) -DECLOP_2VAR_COMP(ulonglong2, <=) -DECLOP_2VAR_COMP(ulonglong2, >=) - -DECLOP_2VAR_COMP(ulonglong2, &&) -DECLOP_2VAR_COMP(ulonglong2, ||) - -DECLOP_2VAR_1IN_1OUT(ulonglong2, ~) -DECLOP_2VAR_1IN_BOOLOUT(ulonglong2, !) - -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, float) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, double) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, signed long long) - -// UNSIGNED LONGLONG3 - -DECLOP_3VAR_2IN_1OUT(ulonglong3, +) -DECLOP_3VAR_2IN_1OUT(ulonglong3, -) -DECLOP_3VAR_2IN_1OUT(ulonglong3, *) -DECLOP_3VAR_2IN_1OUT(ulonglong3, /) -DECLOP_3VAR_2IN_1OUT(ulonglong3, %) -DECLOP_3VAR_2IN_1OUT(ulonglong3, &) -DECLOP_3VAR_2IN_1OUT(ulonglong3, |) -DECLOP_3VAR_2IN_1OUT(ulonglong3, ^) -DECLOP_3VAR_2IN_1OUT(ulonglong3, <<) -DECLOP_3VAR_2IN_1OUT(ulonglong3, >>) - -DECLOP_3VAR_ASSIGN(ulonglong3, +=) -DECLOP_3VAR_ASSIGN(ulonglong3, -=) -DECLOP_3VAR_ASSIGN(ulonglong3, *=) -DECLOP_3VAR_ASSIGN(ulonglong3, /=) -DECLOP_3VAR_ASSIGN(ulonglong3, %=) -DECLOP_3VAR_ASSIGN(ulonglong3, &=) -DECLOP_3VAR_ASSIGN(ulonglong3, |=) -DECLOP_3VAR_ASSIGN(ulonglong3, ^=) -DECLOP_3VAR_ASSIGN(ulonglong3, <<=) -DECLOP_3VAR_ASSIGN(ulonglong3, >>=) - -DECLOP_3VAR_PREOP(ulonglong3, ++) -DECLOP_3VAR_PREOP(ulonglong3, --) - -DECLOP_3VAR_POSTOP(ulonglong3, ++) -DECLOP_3VAR_POSTOP(ulonglong3, --) - -DECLOP_3VAR_COMP(ulonglong3, ==) -DECLOP_3VAR_COMP(ulonglong3, !=) -DECLOP_3VAR_COMP(ulonglong3, <) -DECLOP_3VAR_COMP(ulonglong3, >) -DECLOP_3VAR_COMP(ulonglong3, <=) -DECLOP_3VAR_COMP(ulonglong3, >=) - -DECLOP_3VAR_COMP(ulonglong3, &&) -DECLOP_3VAR_COMP(ulonglong3, ||) - -DECLOP_3VAR_1IN_1OUT(ulonglong3, ~) -DECLOP_3VAR_1IN_BOOLOUT(ulonglong3, !) - -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, float) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, double) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, signed long long) - -// UNSIGNED LONGLONG4 - -DECLOP_4VAR_2IN_1OUT(ulonglong4, +) -DECLOP_4VAR_2IN_1OUT(ulonglong4, -) -DECLOP_4VAR_2IN_1OUT(ulonglong4, *) -DECLOP_4VAR_2IN_1OUT(ulonglong4, /) -DECLOP_4VAR_2IN_1OUT(ulonglong4, %) -DECLOP_4VAR_2IN_1OUT(ulonglong4, &) -DECLOP_4VAR_2IN_1OUT(ulonglong4, |) -DECLOP_4VAR_2IN_1OUT(ulonglong4, ^) -DECLOP_4VAR_2IN_1OUT(ulonglong4, <<) -DECLOP_4VAR_2IN_1OUT(ulonglong4, >>) - -DECLOP_4VAR_ASSIGN(ulonglong4, +=) -DECLOP_4VAR_ASSIGN(ulonglong4, -=) -DECLOP_4VAR_ASSIGN(ulonglong4, *=) -DECLOP_4VAR_ASSIGN(ulonglong4, /=) -DECLOP_4VAR_ASSIGN(ulonglong4, %=) -DECLOP_4VAR_ASSIGN(ulonglong4, &=) -DECLOP_4VAR_ASSIGN(ulonglong4, |=) -DECLOP_4VAR_ASSIGN(ulonglong4, ^=) -DECLOP_4VAR_ASSIGN(ulonglong4, <<=) -DECLOP_4VAR_ASSIGN(ulonglong4, >>=) - -DECLOP_4VAR_PREOP(ulonglong4, ++) -DECLOP_4VAR_PREOP(ulonglong4, --) - -DECLOP_4VAR_POSTOP(ulonglong4, ++) -DECLOP_4VAR_POSTOP(ulonglong4, --) - -DECLOP_4VAR_COMP(ulonglong4, ==) -DECLOP_4VAR_COMP(ulonglong4, !=) -DECLOP_4VAR_COMP(ulonglong4, <) -DECLOP_4VAR_COMP(ulonglong4, >) -DECLOP_4VAR_COMP(ulonglong4, <=) -DECLOP_4VAR_COMP(ulonglong4, >=) - -DECLOP_4VAR_COMP(ulonglong4, &&) -DECLOP_4VAR_COMP(ulonglong4, ||) - -DECLOP_4VAR_1IN_1OUT(ulonglong4, ~) -DECLOP_4VAR_1IN_BOOLOUT(ulonglong4, !) - -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, float) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, double) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, signed long long) - -// SIGNED LONGLONG1 - -DECLOP_1VAR_2IN_1OUT(longlong1, +) -DECLOP_1VAR_2IN_1OUT(longlong1, -) -DECLOP_1VAR_2IN_1OUT(longlong1, *) -DECLOP_1VAR_2IN_1OUT(longlong1, /) -DECLOP_1VAR_2IN_1OUT(longlong1, %) -DECLOP_1VAR_2IN_1OUT(longlong1, &) -DECLOP_1VAR_2IN_1OUT(longlong1, |) -DECLOP_1VAR_2IN_1OUT(longlong1, ^) -DECLOP_1VAR_2IN_1OUT(longlong1, <<) -DECLOP_1VAR_2IN_1OUT(longlong1, >>) - - -DECLOP_1VAR_ASSIGN(longlong1, +=) -DECLOP_1VAR_ASSIGN(longlong1, -=) -DECLOP_1VAR_ASSIGN(longlong1, *=) -DECLOP_1VAR_ASSIGN(longlong1, /=) -DECLOP_1VAR_ASSIGN(longlong1, %=) -DECLOP_1VAR_ASSIGN(longlong1, &=) -DECLOP_1VAR_ASSIGN(longlong1, |=) -DECLOP_1VAR_ASSIGN(longlong1, ^=) -DECLOP_1VAR_ASSIGN(longlong1, <<=) -DECLOP_1VAR_ASSIGN(longlong1, >>=) - -DECLOP_1VAR_PREOP(longlong1, ++) -DECLOP_1VAR_PREOP(longlong1, --) - -DECLOP_1VAR_POSTOP(longlong1, ++) -DECLOP_1VAR_POSTOP(longlong1, --) - -DECLOP_1VAR_COMP(longlong1, ==) -DECLOP_1VAR_COMP(longlong1, !=) -DECLOP_1VAR_COMP(longlong1, <) -DECLOP_1VAR_COMP(longlong1, >) -DECLOP_1VAR_COMP(longlong1, <=) -DECLOP_1VAR_COMP(longlong1, >=) - -DECLOP_1VAR_COMP(longlong1, &&) -DECLOP_1VAR_COMP(longlong1, ||) - -DECLOP_1VAR_1IN_1OUT(longlong1, ~) -DECLOP_1VAR_1IN_BOOLOUT(longlong1, !) - -DECLOP_1VAR_SCALE_PRODUCT(longlong1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, float) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, double) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, signed long long) - -// SIGNED LONGLONG2 - -DECLOP_2VAR_2IN_1OUT(longlong2, +) -DECLOP_2VAR_2IN_1OUT(longlong2, -) -DECLOP_2VAR_2IN_1OUT(longlong2, *) -DECLOP_2VAR_2IN_1OUT(longlong2, /) -DECLOP_2VAR_2IN_1OUT(longlong2, %) -DECLOP_2VAR_2IN_1OUT(longlong2, &) -DECLOP_2VAR_2IN_1OUT(longlong2, |) -DECLOP_2VAR_2IN_1OUT(longlong2, ^) -DECLOP_2VAR_2IN_1OUT(longlong2, <<) -DECLOP_2VAR_2IN_1OUT(longlong2, >>) - -DECLOP_2VAR_ASSIGN(longlong2, +=) -DECLOP_2VAR_ASSIGN(longlong2, -=) -DECLOP_2VAR_ASSIGN(longlong2, *=) -DECLOP_2VAR_ASSIGN(longlong2, /=) -DECLOP_2VAR_ASSIGN(longlong2, %=) -DECLOP_2VAR_ASSIGN(longlong2, &=) -DECLOP_2VAR_ASSIGN(longlong2, |=) -DECLOP_2VAR_ASSIGN(longlong2, ^=) -DECLOP_2VAR_ASSIGN(longlong2, <<=) -DECLOP_2VAR_ASSIGN(longlong2, >>=) - -DECLOP_2VAR_PREOP(longlong2, ++) -DECLOP_2VAR_PREOP(longlong2, --) - -DECLOP_2VAR_POSTOP(longlong2, ++) -DECLOP_2VAR_POSTOP(longlong2, --) - -DECLOP_2VAR_COMP(longlong2, ==) -DECLOP_2VAR_COMP(longlong2, !=) -DECLOP_2VAR_COMP(longlong2, <) -DECLOP_2VAR_COMP(longlong2, >) -DECLOP_2VAR_COMP(longlong2, <=) -DECLOP_2VAR_COMP(longlong2, >=) - -DECLOP_2VAR_COMP(longlong2, &&) -DECLOP_2VAR_COMP(longlong2, ||) - -DECLOP_2VAR_1IN_1OUT(longlong2, ~) -DECLOP_2VAR_1IN_BOOLOUT(longlong2, !) - -DECLOP_2VAR_SCALE_PRODUCT(longlong2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, float) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, double) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, signed long long) - -// SIGNED LONGLONG3 - -DECLOP_3VAR_2IN_1OUT(longlong3, +) -DECLOP_3VAR_2IN_1OUT(longlong3, -) -DECLOP_3VAR_2IN_1OUT(longlong3, *) -DECLOP_3VAR_2IN_1OUT(longlong3, /) -DECLOP_3VAR_2IN_1OUT(longlong3, %) -DECLOP_3VAR_2IN_1OUT(longlong3, &) -DECLOP_3VAR_2IN_1OUT(longlong3, |) -DECLOP_3VAR_2IN_1OUT(longlong3, ^) -DECLOP_3VAR_2IN_1OUT(longlong3, <<) -DECLOP_3VAR_2IN_1OUT(longlong3, >>) - -DECLOP_3VAR_ASSIGN(longlong3, +=) -DECLOP_3VAR_ASSIGN(longlong3, -=) -DECLOP_3VAR_ASSIGN(longlong3, *=) -DECLOP_3VAR_ASSIGN(longlong3, /=) -DECLOP_3VAR_ASSIGN(longlong3, %=) -DECLOP_3VAR_ASSIGN(longlong3, &=) -DECLOP_3VAR_ASSIGN(longlong3, |=) -DECLOP_3VAR_ASSIGN(longlong3, ^=) -DECLOP_3VAR_ASSIGN(longlong3, <<=) -DECLOP_3VAR_ASSIGN(longlong3, >>=) - -DECLOP_3VAR_PREOP(longlong3, ++) -DECLOP_3VAR_PREOP(longlong3, --) - -DECLOP_3VAR_POSTOP(longlong3, ++) -DECLOP_3VAR_POSTOP(longlong3, --) - -DECLOP_3VAR_COMP(longlong3, ==) -DECLOP_3VAR_COMP(longlong3, !=) -DECLOP_3VAR_COMP(longlong3, <) -DECLOP_3VAR_COMP(longlong3, >) -DECLOP_3VAR_COMP(longlong3, <=) -DECLOP_3VAR_COMP(longlong3, >=) - -DECLOP_3VAR_COMP(longlong3, &&) -DECLOP_3VAR_COMP(longlong3, ||) - -DECLOP_3VAR_1IN_1OUT(longlong3, ~) -DECLOP_3VAR_1IN_BOOLOUT(longlong3, !) - -DECLOP_3VAR_SCALE_PRODUCT(longlong3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, float) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, double) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, signed long long) - -// SIGNED LONGLONG4 - -DECLOP_4VAR_2IN_1OUT(longlong4, +) -DECLOP_4VAR_2IN_1OUT(longlong4, -) -DECLOP_4VAR_2IN_1OUT(longlong4, *) -DECLOP_4VAR_2IN_1OUT(longlong4, /) -DECLOP_4VAR_2IN_1OUT(longlong4, %) -DECLOP_4VAR_2IN_1OUT(longlong4, &) -DECLOP_4VAR_2IN_1OUT(longlong4, |) -DECLOP_4VAR_2IN_1OUT(longlong4, ^) -DECLOP_4VAR_2IN_1OUT(longlong4, <<) -DECLOP_4VAR_2IN_1OUT(longlong4, >>) - -DECLOP_4VAR_ASSIGN(longlong4, +=) -DECLOP_4VAR_ASSIGN(longlong4, -=) -DECLOP_4VAR_ASSIGN(longlong4, *=) -DECLOP_4VAR_ASSIGN(longlong4, /=) -DECLOP_4VAR_ASSIGN(longlong4, %=) -DECLOP_4VAR_ASSIGN(longlong4, &=) -DECLOP_4VAR_ASSIGN(longlong4, |=) -DECLOP_4VAR_ASSIGN(longlong4, ^=) -DECLOP_4VAR_ASSIGN(longlong4, <<=) -DECLOP_4VAR_ASSIGN(longlong4, >>=) - -DECLOP_4VAR_PREOP(longlong4, ++) -DECLOP_4VAR_PREOP(longlong4, --) - -DECLOP_4VAR_POSTOP(longlong4, ++) -DECLOP_4VAR_POSTOP(longlong4, --) - -DECLOP_4VAR_COMP(longlong4, ==) -DECLOP_4VAR_COMP(longlong4, !=) -DECLOP_4VAR_COMP(longlong4, <) -DECLOP_4VAR_COMP(longlong4, >) -DECLOP_4VAR_COMP(longlong4, <=) -DECLOP_4VAR_COMP(longlong4, >=) - -DECLOP_4VAR_COMP(longlong4, &&) -DECLOP_4VAR_COMP(longlong4, ||) - -DECLOP_4VAR_1IN_1OUT(longlong4, ~) -DECLOP_4VAR_1IN_BOOLOUT(longlong4, !) - -DECLOP_4VAR_SCALE_PRODUCT(longlong4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, float) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, double) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, signed long long) - - -#endif - - -#endif +#endif \ No newline at end of file diff --git a/projects/hip/include/hip/hcc_detail/llvm_intrinsics.h b/projects/hip/include/hip/hcc_detail/llvm_intrinsics.h new file mode 100644 index 0000000000..dc6fd05c52 --- /dev/null +++ b/projects/hip/include/hip/hcc_detail/llvm_intrinsics.h @@ -0,0 +1,70 @@ +/* +Copyright (c) 2015 - present Advanced Micro Devices, Inc. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +/** + * @file hcc_detail/llvm_intrinsics.h + * @brief Contains declarations for wrapper functions for llvm intrinsics + * like llvm.amdgcn.s.barrier. + */ + +#ifndef HIP_INCLUDE_HIP_HCC_DETAIL_LLVM_INTRINSICS_H +#define HIP_INCLUDE_HIP_HCC_DETAIL_LLVM_INTRINSICS_H + +#include "hip/hcc_detail/host_defines.h" + +__device__ +__attribute__((convergent)) +ulong __llvm_amdgcn_icmp_i32(uint x, uint y, uint z) __asm("llvm.amdgcn.icmp.i32"); + +__device__ +unsigned __llvm_amdgcn_groupstaticsize() __asm("llvm.amdgcn.groupstaticsize"); + +__device__ +unsigned int __llvm_bitrev_b32(unsigned int src0) __asm("llvm.bitreverse.i32"); + +__device__ +uint64_t __llvm_bitrev_b64(uint64_t src0) __asm("llvm.bitreverse.i64"); + +extern +__device__ +__attribute__((const)) +unsigned int __mbcnt_lo(unsigned int x, unsigned int y) __asm("llvm.amdgcn.mbcnt.lo"); + +extern +__device__ +__attribute__((const)) +unsigned int __mbcnt_hi(unsigned int x, unsigned int y) __asm("llvm.amdgcn.mbcnt.hi"); + +__device__ +int __llvm_amdgcn_ds_bpermute(int index, int src) __asm("llvm.amdgcn.ds.bpermute"); + +__device__ +int __llvm_amdgcn_ds_permute(int index, int src) __asm("llvm.amdgcn.ds.permute"); + +__device__ +int __llvm_amdgcn_ds_swizzle(int index, int pattern) __asm("llvm.amdgcn.ds.swizzle"); + +__device__ +int __llvm_amdgcn_move_dpp(int src, int dpp_ctrl, int row_mask, int bank_mask, + bool bound_ctrl) __asm("llvm.amdgcn.mov.dpp.i32"); + +#endif diff --git a/projects/hip/include/hip/hcc_detail/surface_functions.h b/projects/hip/include/hip/hcc_detail/surface_functions.h index 562cc440ed..607f221901 100644 --- a/projects/hip/include/hip/hcc_detail/surface_functions.h +++ b/projects/hip/include/hip/hcc_detail/surface_functions.h @@ -23,8 +23,6 @@ THE SOFTWARE. #ifndef HIP_INCLUDE_HIP_HCC_DETAIL_SURFACE_FUNCTIONS_H #define HIP_INCLUDE_HIP_HCC_DETAIL_SURFACE_FUNCTIONS_H -#include -#include #include #define __SURFACE_FUNCTIONS_DECL__ static __inline__ __device__ diff --git a/projects/hip/include/hip/hcc_detail/texture_functions.h b/projects/hip/include/hip/hcc_detail/texture_functions.h index 8a7aec9212..999f97e65e 100644 --- a/projects/hip/include/hip/hcc_detail/texture_functions.h +++ b/projects/hip/include/hip/hcc_detail/texture_functions.h @@ -110,47 +110,47 @@ union TData { #define TEXTURE_RETURN_UNSIGNED return texel.u.x; -#define TEXTURE_RETURN_CHAR_X return char1(texel.i.x); +#define TEXTURE_RETURN_CHAR_X return make_char1(texel.i.x); -#define TEXTURE_RETURN_UCHAR_X return uchar1(texel.u.x); +#define TEXTURE_RETURN_UCHAR_X return make_uchar1(texel.u.x); -#define TEXTURE_RETURN_SHORT_X return short1(texel.i.x); +#define TEXTURE_RETURN_SHORT_X return make_short1(texel.i.x); -#define TEXTURE_RETURN_USHORT_X return ushort1(texel.u.x); +#define TEXTURE_RETURN_USHORT_X return make_ushort1(texel.u.x); -#define TEXTURE_RETURN_INT_X return int1(texel.i.x); +#define TEXTURE_RETURN_INT_X return make_int1(texel.i.x); -#define TEXTURE_RETURN_UINT_X return uint1(texel.u.x); +#define TEXTURE_RETURN_UINT_X return make_uint1(texel.u.x); -#define TEXTURE_RETURN_FLOAT_X return float1(texel.f.x); +#define TEXTURE_RETURN_FLOAT_X return make_float1(texel.f.x); -#define TEXTURE_RETURN_CHAR_XY return char2(texel.i.x, texel.i.y); +#define TEXTURE_RETURN_CHAR_XY return make_char2(texel.i.x, texel.i.y); -#define TEXTURE_RETURN_UCHAR_XY return uchar2(texel.u.x, texel.u.y); +#define TEXTURE_RETURN_UCHAR_XY return make_uchar2(texel.u.x, texel.u.y); -#define TEXTURE_RETURN_SHORT_XY return short2(texel.i.x, texel.i.y); +#define TEXTURE_RETURN_SHORT_XY return make_short2(texel.i.x, texel.i.y); -#define TEXTURE_RETURN_USHORT_XY return ushort2(texel.u.x, texel.u.y); +#define TEXTURE_RETURN_USHORT_XY return make_ushort2(texel.u.x, texel.u.y); -#define TEXTURE_RETURN_INT_XY return int2(texel.i.x, texel.i.y); +#define TEXTURE_RETURN_INT_XY return make_int2(texel.i.x, texel.i.y); -#define TEXTURE_RETURN_UINT_XY return uint2(texel.u.x, texel.u.y); +#define TEXTURE_RETURN_UINT_XY return make_uint2(texel.u.x, texel.u.y); -#define TEXTURE_RETURN_FLOAT_XY return float2(texel.f.x, texel.f.y); +#define TEXTURE_RETURN_FLOAT_XY return make_float2(texel.f.x, texel.f.y); -#define TEXTURE_RETURN_CHAR_XYZW return char4(texel.i.x, texel.i.y, texel.i.z, texel.i.w); +#define TEXTURE_RETURN_CHAR_XYZW return make_char4(texel.i.x, texel.i.y, texel.i.z, texel.i.w); -#define TEXTURE_RETURN_UCHAR_XYZW return uchar4(texel.u.x, texel.u.y, texel.u.z, texel.u.w); +#define TEXTURE_RETURN_UCHAR_XYZW return make_uchar4(texel.u.x, texel.u.y, texel.u.z, texel.u.w); -#define TEXTURE_RETURN_SHORT_XYZW return short4(texel.i.x, texel.i.y, texel.i.z, texel.i.w); +#define TEXTURE_RETURN_SHORT_XYZW return make_short4(texel.i.x, texel.i.y, texel.i.z, texel.i.w); -#define TEXTURE_RETURN_USHORT_XYZW return ushort4(texel.u.x, texel.u.y, texel.u.z, texel.u.w); +#define TEXTURE_RETURN_USHORT_XYZW return make_ushort4(texel.u.x, texel.u.y, texel.u.z, texel.u.w); -#define TEXTURE_RETURN_INT_XYZW return int4(texel.i.x, texel.i.y, texel.i.z, texel.i.w); +#define TEXTURE_RETURN_INT_XYZW return make_int4(texel.i.x, texel.i.y, texel.i.z, texel.i.w); -#define TEXTURE_RETURN_UINT_XYZW return uint4(texel.u.x, texel.u.y, texel.u.z, texel.u.w); +#define TEXTURE_RETURN_UINT_XYZW return make_uint4(texel.u.x, texel.u.y, texel.u.z, texel.u.w); -#define TEXTURE_RETURN_FLOAT_XYZW return float4(texel.f.x, texel.f.y, texel.f.z, texel.f.w); +#define TEXTURE_RETURN_FLOAT_XYZW return make_float4(texel.f.x, texel.f.y, texel.f.z, texel.f.w); extern "C" { hc::short_vector::float4::vector_value_type __ockl_image_sample_1D(unsigned int ADDRESS_SPACE_CONSTANT* i, diff --git a/projects/hip/packaging/hip_hcc.txt b/projects/hip/packaging/hip_hcc.txt index 04293f2044..9d4b96761d 100644 --- a/projects/hip/packaging/hip_hcc.txt +++ b/projects/hip/packaging/hip_hcc.txt @@ -5,7 +5,6 @@ install(FILES @PROJECT_BINARY_DIR@/libhip_hcc.so DESTINATION lib) install(FILES @PROJECT_BINARY_DIR@/libhip_hcc_static.a DESTINATION lib) install(FILES @PROJECT_BINARY_DIR@/libhip_device.a DESTINATION lib) install(FILES @PROJECT_BINARY_DIR@/.hipInfo DESTINATION lib) -install(FILES @hip_SOURCE_DIR@/src/hip_hc.ll DESTINATION lib) install(FILES @PROJECT_BINARY_DIR@/hip-config.cmake @PROJECT_BINARY_DIR@/hip-config-version.cmake DESTINATION lib/cmake/hip) install(FILES @hip_SOURCE_DIR@/packaging/hip-targets.cmake @hip_SOURCE_DIR@/packaging/hip-targets-release.cmake DESTINATION lib/cmake/hip) diff --git a/projects/hip/src/device_functions.cpp b/projects/hip/src/device_functions.cpp deleted file mode 100644 index 8ef19bab3f..0000000000 --- a/projects/hip/src/device_functions.cpp +++ /dev/null @@ -1,387 +0,0 @@ -/* -Copyright (c) 2015 - present Advanced Micro Devices, Inc. All rights reserved. -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. -*/ - -#include -#include -#include -#include -#include "device_util.h" - -__device__ float __double2float_rd(double x) { return (double)x; } -__device__ float __double2float_rn(double x) { return (double)x; } -__device__ float __double2float_ru(double x) { return (double)x; } -__device__ float __double2float_rz(double x) { return (double)x; } - - -__device__ int __double2hiint(double x) { - static_assert(sizeof(double) == 2 * sizeof(int), ""); - - int tmp[2]; - __builtin_memcpy(tmp, &x, sizeof(tmp)); - - return tmp[1]; -} -__device__ int __double2loint(double x) { - static_assert(sizeof(double) == 2 * sizeof(int), ""); - - int tmp[2]; - __builtin_memcpy(tmp, &x, sizeof(tmp)); - - return tmp[0]; -} - - -__device__ int __double2int_rd(double x) { return (int)x; } -__device__ int __double2int_rn(double x) { return (int)x; } -__device__ int __double2int_ru(double x) { return (int)x; } -__device__ int __double2int_rz(double x) { return (int)x; } - -__device__ long long int __double2ll_rd(double x) { return (long long int)x; } -__device__ long long int __double2ll_rn(double x) { return (long long int)x; } -__device__ long long int __double2ll_ru(double x) { return (long long int)x; } -__device__ long long int __double2ll_rz(double x) { return (long long int)x; } - - -__device__ unsigned int __double2uint_rd(double x) { return (unsigned int)x; } -__device__ unsigned int __double2uint_rn(double x) { return (unsigned int)x; } -__device__ unsigned int __double2uint_ru(double x) { return (unsigned int)x; } -__device__ unsigned int __double2uint_rz(double x) { return (unsigned int)x; } - -__device__ unsigned long long int __double2ull_rd(double x) { return (unsigned long long int)x; } -__device__ unsigned long long int __double2ull_rn(double x) { return (unsigned long long int)x; } -__device__ unsigned long long int __double2ull_ru(double x) { return (unsigned long long int)x; } -__device__ unsigned long long int __double2ull_rz(double x) { return (unsigned long long int)x; } - -__device__ long long int __double_as_longlong(double x) { - static_assert(sizeof(long long) == sizeof(double), ""); - - long long tmp; - __builtin_memcpy(&tmp, &x, sizeof(tmp)); - - return tmp; -} - -__device__ int __float2int_rd(float x) { return (int)__ocml_floor_f32(x); } -__device__ int __float2int_rn(float x) { return (int)__ocml_rint_f32(x); } -__device__ int __float2int_ru(float x) { return (int)__ocml_ceil_f32(x); } -__device__ int __float2int_rz(float x) { return (int)__ocml_trunc_f32(x); } - -__device__ long long int __float2ll_rd(float x) { return (long long int)x; } -__device__ long long int __float2ll_rn(float x) { return (long long int)x; } -__device__ long long int __float2ll_ru(float x) { return (long long int)x; } -__device__ long long int __float2ll_rz(float x) { return (long long int)x; } - -__device__ unsigned int __float2uint_rd(float x) { return (unsigned int)x; } -__device__ unsigned int __float2uint_rn(float x) { return (unsigned int)x; } -__device__ unsigned int __float2uint_ru(float x) { return (unsigned int)x; } -__device__ unsigned int __float2uint_rz(float x) { return (unsigned int)x; } - -__device__ unsigned long long int __float2ull_rd(float x) { return (unsigned long long int)x; } -__device__ unsigned long long int __float2ull_rn(float x) { return (unsigned long long int)x; } -__device__ unsigned long long int __float2ull_ru(float x) { return (unsigned long long int)x; } -__device__ unsigned long long int __float2ull_rz(float x) { return (unsigned long long int)x; } - -__device__ int __float_as_int(float x) { - static_assert(sizeof(int) == sizeof(float), ""); - - int tmp; - __builtin_memcpy(&tmp, &x, sizeof(tmp)); - - return tmp; -} -__device__ unsigned int __float_as_uint(float x) { - static_assert(sizeof(unsigned int) == sizeof(float), ""); - - unsigned int tmp; - __builtin_memcpy(&tmp, &x, sizeof(tmp)); - - return tmp; -} -__device__ double __hiloint2double(int32_t hi, int32_t lo) { - static_assert(sizeof(double) == sizeof(uint64_t), ""); - - uint64_t tmp0 = (static_cast(hi) << 32ull) | static_cast(lo); - double tmp1; - __builtin_memcpy(&tmp1, &tmp0, sizeof(tmp0)); - - return tmp1; -} -__device__ double __int2double_rn(int x) { return (double)x; } - -__device__ float __int2float_rd(int x) { return (float)x; } -__device__ float __int2float_rn(int x) { return (float)x; } -__device__ float __int2float_ru(int x) { return (float)x; } -__device__ float __int2float_rz(int x) { return (float)x; } - -__device__ float __int_as_float(int x) { - static_assert(sizeof(float) == sizeof(int), ""); - - float tmp; - __builtin_memcpy(&tmp, &x, sizeof(tmp)); - - return tmp; -} - -__device__ double __ll2double_rd(long long int x) { return (double)x; } -__device__ double __ll2double_rn(long long int x) { return (double)x; } -__device__ double __ll2double_ru(long long int x) { return (double)x; } -__device__ double __ll2double_rz(long long int x) { return (double)x; } - -__device__ float __ll2float_rd(long long int x) { return (float)x; } -__device__ float __ll2float_rn(long long int x) { return (float)x; } -__device__ float __ll2float_ru(long long int x) { return (float)x; } -__device__ float __ll2float_rz(long long int x) { return (float)x; } - -__device__ double __longlong_as_double(long long int x) { - static_assert(sizeof(double) == sizeof(long long), ""); - - double tmp; - __builtin_memcpy(&tmp, &x, sizeof(tmp)); - - return x; -} - -__device__ double __uint2double_rn(int x) { return (double)x; } - -__device__ float __uint2float_rd(unsigned int x) { return (float)x; } -__device__ float __uint2float_rn(unsigned int x) { return (float)x; } -__device__ float __uint2float_ru(unsigned int x) { return (float)x; } -__device__ float __uint2float_rz(unsigned int x) { return (float)x; } - -__device__ float __uint_as_float(unsigned int x) { - static_assert(sizeof(float) == sizeof(unsigned int), ""); - - float tmp; - __builtin_memcpy(&tmp, &x, sizeof(tmp)); - - return tmp; -} - -__device__ double __ull2double_rd(unsigned long long int x) { return (double)x; } -__device__ double __ull2double_rn(unsigned long long int x) { return (double)x; } -__device__ double __ull2double_ru(unsigned long long int x) { return (double)x; } -__device__ double __ull2double_rz(unsigned long long int x) { return (double)x; } - -__device__ float __ull2float_rd(unsigned long long int x) { return (float)x; } -__device__ float __ull2float_rn(unsigned long long int x) { return (float)x; } -__device__ float __ull2float_ru(unsigned long long int x) { return (float)x; } -__device__ float __ull2float_rz(unsigned long long int x) { return (float)x; } - -/* -Integer Intrinsics -*/ - -// integer intrinsic function __poc __clz __ffs __brev -__device__ unsigned int __popc(unsigned int input) { return hc::__popcount_u32_b32(input); } - -__device__ unsigned int __popcll(unsigned long long int input) { - return hc::__popcount_u32_b64(input); -} - -__device__ unsigned int __clz(unsigned int input) { -#ifdef NVCC_COMPAT - return input == 0 ? 32 : hc::__firstbit_u32_u32(input); -#else - return hc::__firstbit_u32_u32(input); -#endif -} - -__device__ unsigned int __clzll(unsigned long long int input) { -#ifdef NVCC_COMPAT - return input == 0 ? 64 : hc::__firstbit_u32_u64(input); -#else - return hc::__firstbit_u32_u64(input); -#endif -} - -__device__ unsigned int __clz(int input) { -#ifdef NVCC_COMPAT - return input == 0 ? 32 : hc::__firstbit_u32_s32(input); -#else - return hc::__firstbit_u32_s32(input); -#endif -} - -__device__ unsigned int __clzll(long long int input) { -#ifdef NVCC_COMPAT - return input == 0 ? 64 : hc::__firstbit_u32_s64(input); -#else - return hc::__firstbit_u32_s64(input); -#endif -} - -__device__ unsigned int __ffs(unsigned int input) { -#ifdef NVCC_COMPAT - return hc::__lastbit_u32_u32(input) + 1; -#else - return hc::__lastbit_u32_u32(input); -#endif -} - -__device__ unsigned int __ffsll(unsigned long long int input) { -#ifdef NVCC_COMPAT - return hc::__lastbit_u32_u64(input) + 1; -#else - return hc::__lastbit_u32_u64(input); -#endif -} - -__device__ unsigned int __ffs(int input) { -#ifdef NVCC_COMPAT - return hc::__lastbit_u32_s32(input) + 1; -#else - return hc::__lastbit_u32_s32(input); -#endif -} - -__device__ unsigned int __ffsll(long long int input) { -#ifdef NVCC_COMPAT - return hc::__lastbit_u32_s64(input) + 1; -#else - return hc::__lastbit_u32_s64(input); -#endif -} - -__device__ unsigned int __brev(unsigned int input) { return hc::__bitrev_b32(input); } - -__device__ unsigned long long int __brevll(unsigned long long int input) { - return hc::__bitrev_b64(input); -} - -struct ucharHolder { - union { - unsigned char c[4]; - unsigned int ui; - }; -} __attribute__((aligned(4))); - -struct uchar2Holder { - union { - unsigned int ui[2]; - unsigned char c[8]; - }; -} __attribute__((aligned(8))); - -__device__ unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s) { - struct uchar2Holder cHoldVal; - struct ucharHolder cHoldKey; - struct ucharHolder cHoldOut; - cHoldKey.ui = s; - cHoldVal.ui[0] = x; - cHoldVal.ui[1] = y; - cHoldOut.c[0] = cHoldVal.c[cHoldKey.c[0]]; - cHoldOut.c[1] = cHoldVal.c[cHoldKey.c[1]]; - cHoldOut.c[2] = cHoldVal.c[cHoldKey.c[2]]; - cHoldOut.c[3] = cHoldVal.c[cHoldKey.c[3]]; - return cHoldOut.ui; -} - -__device__ long long __mul64hi(long long int x, long long int y) { - ulong x0 = (ulong)x & 0xffffffffUL; - long x1 = x >> 32; - ulong y0 = (ulong)y & 0xffffffffUL; - long y1 = y >> 32; - ulong z0 = x0*y0; - long t = x1*y0 + (z0 >> 32); - long z1 = t & 0xffffffffL; - long z2 = t >> 32; - z1 = x0*y1 + z1; - return x1*y1 + z2 + (z1 >> 32); -} - -__device__ unsigned long long __umul64hi(unsigned long long int x, unsigned long long int y) { - ulong x0 = x & 0xffffffffUL; - ulong x1 = x >> 32; - ulong y0 = y & 0xffffffffUL; - ulong y1 = y >> 32; - ulong z0 = x0*y0; - ulong t = x1*y0 + (z0 >> 32); - ulong z1 = t & 0xffffffffUL; - ulong z2 = t >> 32; - z1 = x0*y1 + z1; - return x1*y1 + z2 + (z1 >> 32); -} - -/* -HIP specific device functions -*/ - -__device__ unsigned __hip_ds_bpermute(int index, unsigned src) { - return hc::__amdgcn_ds_bpermute(index, src); -} - -__device__ float __hip_ds_bpermutef(int index, float src) { - return hc::__amdgcn_ds_bpermute(index, src); -} - -__device__ unsigned __hip_ds_permute(int index, unsigned src) { - return hc::__amdgcn_ds_permute(index, src); -} - -__device__ float __hip_ds_permutef(int index, float src) { - return hc::__amdgcn_ds_permute(index, src); -} - -__device__ unsigned __hip_ds_swizzle(unsigned int src, int pattern) { - return hc::__amdgcn_ds_swizzle(src, pattern); -} - -__device__ float __hip_ds_swizzlef(float src, int pattern) { - return hc::__amdgcn_ds_swizzle(src, pattern); -} - -__device__ int __hip_move_dpp(int src, int dpp_ctrl, int row_mask, int bank_mask, bool bound_ctrl) { - return hc::__amdgcn_move_dpp(src, dpp_ctrl, row_mask, bank_mask, bound_ctrl); -} - -#define MASK1 0x00ff00ff -#define MASK2 0xff00ff00 - -__device__ char4 __hip_hc_add8pk(char4 in1, char4 in2) { - char4 out; - unsigned one1 = in1.a & MASK1; - unsigned one2 = in2.a & MASK1; - out.a = (one1 + one2) & MASK1; - one1 = in1.a & MASK2; - one2 = in2.a & MASK2; - out.a = out.a | ((one1 + one2) & MASK2); - return out; -} - -__device__ char4 __hip_hc_sub8pk(char4 in1, char4 in2) { - char4 out; - unsigned one1 = in1.a & MASK1; - unsigned one2 = in2.a & MASK1; - out.a = (one1 - one2) & MASK1; - one1 = in1.a & MASK2; - one2 = in2.a & MASK2; - out.a = out.a | ((one1 - one2) & MASK2); - return out; -} - -__device__ char4 __hip_hc_mul8pk(char4 in1, char4 in2) { - char4 out; - unsigned one1 = in1.a & MASK1; - unsigned one2 = in2.a & MASK1; - out.a = (one1 * one2) & MASK1; - one1 = in1.a & MASK2; - one2 = in2.a & MASK2; - out.a = out.a | ((one1 * one2) & MASK2); - return out; -} diff --git a/projects/hip/src/device_util.cpp b/projects/hip/src/device_util.cpp index 613e35f0cc..34e198c61d 100644 --- a/projects/hip/src/device_util.cpp +++ b/projects/hip/src/device_util.cpp @@ -144,70 +144,7 @@ __device__ void* __hip_hc_memset(void* dst, uint8_t val, size_t size) { return dst; } -__device__ long long int clock64() { return (long long int)hc::__cycle_u64(); }; -__device__ clock_t clock() { return (clock_t)hc::__cycle_u64(); }; - // abort __device__ void abort() { return hc::abort(); } -// warp vote function __all __any __ballot -__device__ int __all(int input) { return hc::__all(input); } - - -__device__ int __any(int input) { -#ifdef NVCC_COMPAT - if (hc::__any(input) != 0) - return 1; - else - return 0; -#else - return hc::__any(input); -#endif -} - -__device__ unsigned long long int __ballot(int input) { return hc::__ballot(input); } - -// warp shuffle functions -__device__ int __shfl(int input, int lane, int width) { return hc::__shfl(input, lane, width); } - -__device__ int __shfl_up(int input, unsigned int lane_delta, int width) { - return hc::__shfl_up(input, lane_delta, width); -} - -__device__ int __shfl_down(int input, unsigned int lane_delta, int width) { - return hc::__shfl_down(input, lane_delta, width); -} - -__device__ int __shfl_xor(int input, int lane_mask, int width) { - return hc::__shfl_xor(input, lane_mask, width); -} - -__device__ float __shfl(float input, int lane, int width) { return hc::__shfl(input, lane, width); } - -__device__ float __shfl_up(float input, unsigned int lane_delta, int width) { - return hc::__shfl_up(input, lane_delta, width); -} - -__device__ float __shfl_down(float input, unsigned int lane_delta, int width) { - return hc::__shfl_down(input, lane_delta, width); -} - -__device__ float __shfl_xor(float input, int lane_mask, int width) { - return hc::__shfl_xor(input, lane_mask, width); -} - -__host__ __device__ int min(int arg1, int arg2) { - return (int)(hc::precise_math::fmin((float)arg1, (float)arg2)); -} -__host__ __device__ int max(int arg1, int arg2) { - return (int)(hc::precise_math::fmax((float)arg1, (float)arg2)); -} - -__device__ void* __get_dynamicgroupbaseptr() { - return hc::get_dynamic_group_segment_base_pointer(); -} - __host__ void* __get_dynamicgroupbaseptr() { return nullptr; } - - -__device__ void __threadfence_system(void) { std::atomic_thread_fence(std::memory_order_seq_cst); } \ No newline at end of file diff --git a/projects/hip/src/device_util.h b/projects/hip/src/device_util.h index 6603689d82..8fa96da9d9 100644 --- a/projects/hip/src/device_util.h +++ b/projects/hip/src/device_util.h @@ -125,7 +125,6 @@ __device__ double __hip_fast_dsqrt_rd(double x); __device__ double __hip_fast_dsqrt_rn(double x); __device__ double __hip_fast_dsqrt_ru(double x); __device__ double __hip_fast_dsqrt_rz(double x); -__device__ void __threadfence_system(void); float __hip_host_j0f(float x); double __hip_host_j0(double x); diff --git a/projects/hip/src/hip_hc.ll b/projects/hip/src/hip_hc.ll deleted file mode 100644 index aba9205912..0000000000 --- a/projects/hip/src/hip_hc.ll +++ /dev/null @@ -1,30 +0,0 @@ -target datalayout = "e-p:32:32-p1:64:64-p2:64:64-p3:32:32-p4:64:64-p5:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64" -target triple = "amdgcn--amdhsa" - -define i32 @__hip_hc_ir_mul24_int(i32 %a, i32 %b) #1 { - %1 = tail call i32 asm sideeffect "v_mul_i32_i24 $0, $1, $2","=v,v,v"(i32 %a, i32 %b) - ret i32 %1 -} - -define i32 @__hip_hc_ir_umul24_int(i32 %a, i32 %b) #1 { - %1 = tail call i32 asm sideeffect "v_mul_u32_u24 $0, $1, $2","=v,v,v"(i32 %a, i32 %b) - ret i32 %1 -} - -define i32 @__hip_hc_ir_mulhi_int(i32 %a, i32 %b) #1 { - %1 = tail call i32 asm sideeffect "v_mul_hi_i32 $0, $1, $2","=v,v,v"(i32 %a, i32 %b) - ret i32 %1 -} - -define i32 @__hip_hc_ir_umulhi_int(i32 %a, i32 %b) #1 { - %1 = tail call i32 asm sideeffect "v_mul_hi_u32 $0, $1, $2","=v,v,v"(i32 %a, i32 %b) - ret i32 %1 -} - -define i32 @__hip_hc_ir_usad_int(i32 %a, i32 %b, i32 %c) #1 { - %1 = tail call i32 asm sideeffect "v_sad_u32 $0, $1, $2, $3","=v,v,v,v"(i32 %a, i32 %b, i32 %c) - ret i32 %1 -} - -attributes #1 = { alwaysinline nounwind } - diff --git a/projects/hip/src/hip_ldg.cpp b/projects/hip/src/hip_ldg.cpp deleted file mode 100644 index bf94c05571..0000000000 --- a/projects/hip/src/hip_ldg.cpp +++ /dev/null @@ -1,83 +0,0 @@ -/* -Copyright (c) 2015 - present Advanced Micro Devices, Inc. All rights reserved. - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. -*/ - -#include "hip/hcc_detail/hip_ldg.h" -#include "hip/hcc_detail/hip_vector_types.h" - -__device__ char __ldg(const char* ptr) { return *ptr; } - -__device__ char2 __ldg(const char2* ptr) { return *ptr; } - -__device__ char4 __ldg(const char4* ptr) { return *ptr; } - -__device__ signed char __ldg(const signed char* ptr) { return ptr[0]; } - -__device__ unsigned char __ldg(const unsigned char* ptr) { return ptr[0]; } - -__device__ short __ldg(const short* ptr) { return ptr[0]; } - -__device__ short2 __ldg(const short2* ptr) { return ptr[0]; } - -__device__ short4 __ldg(const short4* ptr) { return ptr[0]; } - -__device__ unsigned short __ldg(const unsigned short* ptr) { return ptr[0]; } - -__device__ int __ldg(const int* ptr) { return ptr[0]; } - -__device__ int2 __ldg(const int2* ptr) { return ptr[0]; } - -__device__ int4 __ldg(const int4* ptr) { return ptr[0]; } - -__device__ unsigned int __ldg(const unsigned int* ptr) { return ptr[0]; } - - -__device__ long __ldg(const long* ptr) { return ptr[0]; } - -__device__ unsigned long __ldg(const unsigned long* ptr) { return ptr[0]; } - -__device__ long long __ldg(const long long* ptr) { return ptr[0]; } - -__device__ longlong2 __ldg(const longlong2* ptr) { return ptr[0]; } - -__device__ unsigned long long __ldg(const unsigned long long* ptr) { return ptr[0]; } - -__device__ uchar2 __ldg(const uchar2* ptr) { return ptr[0]; } - -__device__ uchar4 __ldg(const uchar4* ptr) { return ptr[0]; } - -__device__ ushort2 __ldg(const ushort2* ptr) { return ptr[0]; } - -__device__ uint2 __ldg(const uint2* ptr) { return ptr[0]; } - -__device__ uint4 __ldg(const uint4* ptr) { return ptr[0]; } - -__device__ ulonglong2 __ldg(const ulonglong2* ptr) { return ptr[0]; } - -__device__ float __ldg(const float* ptr) { return ptr[0]; } - -__device__ float2 __ldg(const float2* ptr) { return ptr[0]; } - -__device__ float4 __ldg(const float4* ptr) { return ptr[0]; } - -__device__ double __ldg(const double* ptr) { return ptr[0]; } - -__device__ double2 __ldg(const double2* ptr) { return ptr[0]; } diff --git a/projects/hip/tests/src/deviceLib/hipVectorTypes.cpp b/projects/hip/tests/src/deviceLib/hipVectorTypes.cpp index da9e24d079..734878b516 100644 --- a/projects/hip/tests/src/deviceLib/hipVectorTypes.cpp +++ b/projects/hip/tests/src/deviceLib/hipVectorTypes.cpp @@ -26,7832 +26,174 @@ THE SOFTWARE. * HIT_END */ -#include -#include #include + +#include "vector_test_common.h" #include "test_common.h" -#define cmpVal1(in, exp) \ - if (in.x != exp) { \ - std::cout << "Failed at: " << __LINE__ << " in func: " << __func__ \ - << " expected output: " << exp << " but got: " << in.x << std::endl; \ - assert(-1); \ - } -#define cmpVal2(in, exp) \ - if (in.x != exp || in.y != exp) { \ - std::cout << "Failed at: " << __LINE__ << " in func: " << __func__ \ - << " expected output: " << exp << " but got: " << in.x << "," << in.y \ - << std::endl; \ - assert(-1); \ - } +#include +#include +#include +#include -#define cmpVal3(in, exp) \ - if (in.x != exp || in.y != exp || in.z != exp) { \ - std::cout << "Failed at: " << __LINE__ << " in func: " << __func__ \ - << " expected output: " << exp << " but got: " << in.x << "," << in.y << "," \ - << in.z << std::endl; \ - assert(-1); \ - } +using namespace std; -#define cmpVal4(in, exp) \ - if (in.x != exp || in.y != exp || in.z != exp || in.w != exp) { \ - std::cout << "Failed at: " << __LINE__ << " in func: " << __func__ \ - << " expected output: " << exp << " but got: " << in.x << "," << in.y << "," \ - << in.z << "," << in.w << std::endl; \ - assert(-1); \ - } +bool integer_unary_tests(...) { + return true; +} -bool TestUChar1() { - uchar1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); +bool integer_binary_tests(...) { + return true; +} - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); +template< + typename V, + Enable_if_t().x)>{}>* = nullptr> +__device__ +bool integer_unary_tests(V& f1, V& f2) { f1 %= f2; - cmpVal1(f1, 0); + if (f1 != V{0}) return false; f1 &= f2; - cmpVal1(f1, 0); + if (f1 != V{0}) return false; f1 |= f2; - cmpVal1(f1, 1); + if (f1 != V{1}) return false; f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; + if (f1 != V{0}) return false; + f1 = V{1}; f1 <<= f2; - cmpVal1(f1, 2); + if (f1 != V{2}) return false; f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - + if (f1 != V{1}) return false; f2 = ~f1; - cmpVal1(f2, 253); - assert(!f1 == false); - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - uchar1 fa((unsigned char)1); - uchar1 fb((signed char)1); - uchar1 fc((unsigned short)1); - uchar1 fd((signed short)1); - uchar1 fe((unsigned int)1); - uchar1 fg((signed int)1); - uchar1 fh((float)1); - uchar1 fi((double)1); - uchar1 fj((unsigned long)1); - uchar1 fk((signed long)1); - uchar1 fl((unsigned long long)1); - uchar1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; + return f2 == V{~1}; } -bool TestUChar2() { - uchar2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); +template< + typename V, + Enable_if_t().x)>{}>* = nullptr> +__device__ +bool integer_binary_tests(V& f1, V& f2, V& f3) { f3 = f1 % f2; - cmpVal2(f3, 0); + if (f3 != V{0}) return false; f1 = f3 & f2; - cmpVal2(f1, 0); + if (f1 != V{0}) return false; f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; + if (f2 != V{0}) return false; + f1 = V{1}; + f2 = V{2}; f3 = f1 << f2; - cmpVal2(f3, 4); + if (f3 != V{4}) return false; f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, 253); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - uchar2 fa1((unsigned char)1); - uchar2 fa2((unsigned char)1, (unsigned char)1); - uchar2 fb1((signed char)1); - uchar2 fb2((signed char)1, (signed char)1); - uchar2 fc1((unsigned short)1); - uchar2 fc2((unsigned short)1, (unsigned short)1); - uchar2 fd1((signed short)1); - uchar2 fd2((signed short)1, (signed short)1); - uchar2 fe1((unsigned int)1); - uchar2 fe2((unsigned int)1, (unsigned int)1); - uchar2 fg1((signed int)1); - uchar2 fg2((signed int)1, (signed int)1); - uchar2 fh1((float)1); - uchar2 fh2((float)1, (float)1); - uchar2 fi1((double)1); - uchar2 fi2((double)1, (double)1); - uchar2 fj1((unsigned long)1); - uchar2 fj2((unsigned long)1, (unsigned long)1); - uchar2 fk1((signed long)1); - uchar2 fk2((signed long)1, (signed long)1); - uchar2 fl1((unsigned long long)1); - uchar2 fl2((unsigned long long)1, (unsigned long long)1); - uchar2 fm1((signed long long)1); - uchar2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; + return f2 == V{2}; } -bool TestUChar3() { - uchar3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, 253); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - uchar3 fa1((unsigned char)1); - uchar3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - uchar3 fb1((signed char)1); - uchar3 fb2((signed char)1, (signed char)1, (signed char)1); - uchar3 fc1((unsigned short)1); - uchar3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - uchar3 fd1((signed short)1); - uchar3 fd2((signed short)1, (signed short)1, (signed short)1); - uchar3 fe1((unsigned int)1); - uchar3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - uchar3 fg1((signed int)1); - uchar3 fg2((signed int)1, (signed int)1, (signed int)1); - uchar3 fh1((float)1); - uchar3 fh2((float)1, (float)1, (float)1); - uchar3 fi1((double)1); - uchar3 fi2((double)1, (double)1, (double)1); - uchar3 fj1((unsigned long)1); - uchar3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - uchar3 fk1((signed long)1); - uchar3 fk2((signed long)1, (signed long)1, (signed long)1); - uchar3 fl1((unsigned long long)1); - uchar3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - uchar3 fm1((signed long long)1); - uchar3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestUChar4() { - uchar4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, 253); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - - uchar4 fa1((unsigned char)1); - uchar4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - uchar4 fb1((signed char)1); - uchar4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - uchar4 fc1((unsigned short)1); - uchar4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - uchar4 fd1((signed short)1); - uchar4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - uchar4 fe1((unsigned int)1); - uchar4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - uchar4 fg1((signed int)1); - uchar4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - uchar4 fh1((float)1); - uchar4 fh2((float)1, (float)1, (float)1, (float)1); - uchar4 fi1((double)1); - uchar4 fi2((double)1, (double)1, (double)1, (double)1); - uchar4 fj1((unsigned long)1); - uchar4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - uchar4 fk1((signed long)1); - uchar4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - uchar4 fl1((unsigned long long)1); - uchar4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - uchar4 fm1((signed long long)1); - uchar4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestChar1() { - char1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (char)253); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - char1 fa((unsigned char)1); - char1 fb((signed char)1); - char1 fc((unsigned short)1); - char1 fd((signed short)1); - char1 fe((unsigned int)1); - char1 fg((signed int)1); - char1 fh((float)1); - char1 fi((double)1); - char1 fj((unsigned long)1); - char1 fk((signed long)1); - char1 fl((unsigned long long)1); - char1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestChar2() { - char2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (char)253); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - char2 fa1((unsigned char)1); - char2 fa2((unsigned char)1, (unsigned char)1); - char2 fb1((signed char)1); - char2 fb2((signed char)1, (signed char)1); - char2 fc1((unsigned short)1); - char2 fc2((unsigned short)1, (unsigned short)1); - char2 fd1((signed short)1); - char2 fd2((signed short)1, (signed short)1); - char2 fe1((unsigned int)1); - char2 fe2((unsigned int)1, (unsigned int)1); - char2 fg1((signed int)1); - char2 fg2((signed int)1, (signed int)1); - char2 fh1((float)1); - char2 fh2((float)1, (float)1); - char2 fi1((double)1); - char2 fi2((double)1, (double)1); - char2 fj1((unsigned long)1); - char2 fj2((unsigned long)1, (unsigned long)1); - char2 fk1((signed long)1); - char2 fk2((signed long)1, (signed long)1); - char2 fl1((unsigned long long)1); - char2 fl2((unsigned long long)1, (unsigned long long)1); - char2 fm1((signed long long)1); - char2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestChar3() { - char3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (char)253); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - char3 fa1((unsigned char)1); - char3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - char3 fb1((signed char)1); - char3 fb2((signed char)1, (signed char)1, (signed char)1); - char3 fc1((unsigned short)1); - char3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - char3 fd1((signed short)1); - char3 fd2((signed short)1, (signed short)1, (signed short)1); - char3 fe1((unsigned int)1); - char3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - char3 fg1((signed int)1); - char3 fg2((signed int)1, (signed int)1, (signed int)1); - char3 fh1((float)1); - char3 fh2((float)1, (float)1, (float)1); - char3 fi1((double)1); - char3 fi2((double)1, (double)1, (double)1); - char3 fj1((unsigned long)1); - char3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - char3 fk1((signed long)1); - char3 fk2((signed long)1, (signed long)1, (signed long)1); - char3 fl1((unsigned long long)1); - char3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - char3 fm1((signed long long)1); - char3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestChar4() { - char4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (char)253); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - char4 fa1((unsigned char)1); - char4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - char4 fb1((signed char)1); - char4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - char4 fc1((unsigned short)1); - char4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - char4 fd1((signed short)1); - char4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - char4 fe1((unsigned int)1); - char4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - char4 fg1((signed int)1); - char4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - char4 fh1((float)1); - char4 fh2((float)1, (float)1, (float)1, (float)1); - char4 fi1((double)1); - char4 fi2((double)1, (double)1, (double)1, (double)1); - char4 fj1((unsigned long)1); - char4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - char4 fk1((signed long)1); - char4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - char4 fl1((unsigned long long)1); - char4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - char4 fm1((signed long long)1); - char4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestUShort1() { - ushort1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (unsigned short)65533); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - ushort1 fa((unsigned char)1); - ushort1 fb((signed char)1); - ushort1 fc((unsigned short)1); - ushort1 fd((signed short)1); - ushort1 fe((unsigned int)1); - ushort1 fg((signed int)1); - ushort1 fh((float)1); - ushort1 fi((double)1); - ushort1 fj((unsigned long)1); - ushort1 fk((signed long)1); - ushort1 fl((unsigned long long)1); - ushort1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestUShort2() { - ushort2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (unsigned short)65533); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - ushort2 fa1((unsigned char)1); - ushort2 fa2((unsigned char)1, (unsigned char)1); - ushort2 fb1((signed char)1); - ushort2 fb2((signed char)1, (signed char)1); - ushort2 fc1((unsigned short)1); - ushort2 fc2((unsigned short)1, (unsigned short)1); - ushort2 fd1((signed short)1); - ushort2 fd2((signed short)1, (signed short)1); - ushort2 fe1((unsigned int)1); - ushort2 fe2((unsigned int)1, (unsigned int)1); - ushort2 fg1((signed int)1); - ushort2 fg2((signed int)1, (signed int)1); - ushort2 fh1((float)1); - ushort2 fh2((float)1, (float)1); - ushort2 fi1((double)1); - ushort2 fi2((double)1, (double)1); - ushort2 fj1((unsigned long)1); - ushort2 fj2((unsigned long)1, (unsigned long)1); - ushort2 fk1((signed long)1); - ushort2 fk2((signed long)1, (signed long)1); - ushort2 fl1((unsigned long long)1); - ushort2 fl2((unsigned long long)1, (unsigned long long)1); - ushort2 fm1((signed long long)1); - ushort2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestUShort3() { - ushort3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (unsigned short)65533); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - ushort3 fa1((unsigned char)1); - ushort3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - ushort3 fb1((signed char)1); - ushort3 fb2((signed char)1, (signed char)1, (signed char)1); - ushort3 fc1((unsigned short)1); - ushort3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - ushort3 fd1((signed short)1); - ushort3 fd2((signed short)1, (signed short)1, (signed short)1); - ushort3 fe1((unsigned int)1); - ushort3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - ushort3 fg1((signed int)1); - ushort3 fg2((signed int)1, (signed int)1, (signed int)1); - ushort3 fh1((float)1); - ushort3 fh2((float)1, (float)1, (float)1); - ushort3 fi1((double)1); - ushort3 fi2((double)1, (double)1, (double)1); - ushort3 fj1((unsigned long)1); - ushort3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - ushort3 fk1((signed long)1); - ushort3 fk2((signed long)1, (signed long)1, (signed long)1); - ushort3 fl1((unsigned long long)1); - ushort3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - ushort3 fm1((signed long long)1); - ushort3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestUShort4() { - ushort4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (unsigned short)65533); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - ushort4 fa1((unsigned char)1); - ushort4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - ushort4 fb1((signed char)1); - ushort4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - ushort4 fc1((unsigned short)1); - ushort4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - ushort4 fd1((signed short)1); - ushort4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - ushort4 fe1((unsigned int)1); - ushort4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - ushort4 fg1((signed int)1); - ushort4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - ushort4 fh1((float)1); - ushort4 fh2((float)1, (float)1, (float)1, (float)1); - ushort4 fi1((double)1); - ushort4 fi2((double)1, (double)1, (double)1, (double)1); - ushort4 fj1((unsigned long)1); - ushort4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - ushort4 fk1((signed long)1); - ushort4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - ushort4 fl1((unsigned long long)1); - ushort4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - ushort4 fm1((signed long long)1); - ushort4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestShort1() { - short1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (signed short)65533); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - short1 fa((unsigned char)1); - short1 fb((signed char)1); - short1 fc((unsigned short)1); - short1 fd((signed short)1); - short1 fe((unsigned int)1); - short1 fg((signed int)1); - short1 fh((float)1); - short1 fi((double)1); - short1 fj((unsigned long)1); - short1 fk((signed long)1); - short1 fl((unsigned long long)1); - short1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestShort2() { - short2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (signed short)65533); - assert(!f1 == false); - - cmpVal2(f1, 3); - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - short2 fa1((unsigned char)1); - short2 fa2((unsigned char)1, (unsigned char)1); - short2 fb1((signed char)1); - short2 fb2((signed char)1, (signed char)1); - short2 fc1((unsigned short)1); - short2 fc2((unsigned short)1, (unsigned short)1); - short2 fd1((signed short)1); - short2 fd2((signed short)1, (signed short)1); - short2 fe1((unsigned int)1); - short2 fe2((unsigned int)1, (unsigned int)1); - short2 fg1((signed int)1); - short2 fg2((signed int)1, (signed int)1); - short2 fh1((float)1); - short2 fh2((float)1, (float)1); - short2 fi1((double)1); - short2 fi2((double)1, (double)1); - short2 fj1((unsigned long)1); - short2 fj2((unsigned long)1, (unsigned long)1); - short2 fk1((signed long)1); - short2 fk2((signed long)1, (signed long)1); - short2 fl1((unsigned long long)1); - short2 fl2((unsigned long long)1, (unsigned long long)1); - short2 fm1((signed long long)1); - short2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestShort3() { - short3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (signed short)65533); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - short3 fa1((unsigned char)1); - short3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - short3 fb1((signed char)1); - short3 fb2((signed char)1, (signed char)1, (signed char)1); - short3 fc1((unsigned short)1); - short3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - short3 fd1((signed short)1); - short3 fd2((signed short)1, (signed short)1, (signed short)1); - short3 fe1((unsigned int)1); - short3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - short3 fg1((signed int)1); - short3 fg2((signed int)1, (signed int)1, (signed int)1); - short3 fh1((float)1); - short3 fh2((float)1, (float)1, (float)1); - short3 fi1((double)1); - short3 fi2((double)1, (double)1, (double)1); - short3 fj1((unsigned long)1); - short3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - short3 fk1((signed long)1); - short3 fk2((signed long)1, (signed long)1, (signed long)1); - short3 fl1((unsigned long long)1); - short3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - short3 fm1((signed long long)1); - short3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestShort4() { - short4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (signed short)65533); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - short4 fa1((unsigned char)1); - short4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - short4 fb1((signed char)1); - short4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - short4 fc1((unsigned short)1); - short4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - short4 fd1((signed short)1); - short4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - short4 fe1((unsigned int)1); - short4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - short4 fg1((signed int)1); - short4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - short4 fh1((float)1); - short4 fh2((float)1, (float)1, (float)1, (float)1); - short4 fi1((double)1); - short4 fi2((double)1, (double)1, (double)1, (double)1); - short4 fj1((unsigned long)1); - short4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - short4 fk1((signed long)1); - short4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - short4 fl1((unsigned long long)1); - short4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - short4 fm1((signed long long)1); - short4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestUInt1() { - uint1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (unsigned int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - uint1 fa((unsigned char)1); - uint1 fb((signed char)1); - uint1 fc((unsigned short)1); - uint1 fd((signed short)1); - uint1 fe((unsigned int)1); - uint1 fg((signed int)1); - uint1 fh((float)1); - uint1 fi((double)1); - uint1 fj((unsigned long)1); - uint1 fk((signed long)1); - uint1 fl((unsigned long long)1); - uint1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestUInt2() { - uint2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (unsigned int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - uint2 fa1((unsigned char)1); - uint2 fa2((unsigned char)1, (unsigned char)1); - uint2 fb1((signed char)1); - uint2 fb2((signed char)1, (signed char)1); - uint2 fc1((unsigned short)1); - uint2 fc2((unsigned short)1, (unsigned short)1); - uint2 fd1((signed short)1); - uint2 fd2((signed short)1, (signed short)1); - uint2 fe1((unsigned int)1); - uint2 fe2((unsigned int)1, (unsigned int)1); - uint2 fg1((signed int)1); - uint2 fg2((signed int)1, (signed int)1); - uint2 fh1((float)1); - uint2 fh2((float)1, (float)1); - uint2 fi1((double)1); - uint2 fi2((double)1, (double)1); - uint2 fj1((unsigned long)1); - uint2 fj2((unsigned long)1, (unsigned long)1); - uint2 fk1((signed long)1); - uint2 fk2((signed long)1, (signed long)1); - uint2 fl1((unsigned long long)1); - uint2 fl2((unsigned long long)1, (unsigned long long)1); - uint2 fm1((signed long long)1); - uint2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestUInt3() { - uint3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (unsigned int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - uint3 fa1((unsigned char)1); - uint3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - uint3 fb1((signed char)1); - uint3 fb2((signed char)1, (signed char)1, (signed char)1); - uint3 fc1((unsigned short)1); - uint3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - uint3 fd1((signed short)1); - uint3 fd2((signed short)1, (signed short)1, (signed short)1); - uint3 fe1((unsigned int)1); - uint3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - uint3 fg1((signed int)1); - uint3 fg2((signed int)1, (signed int)1, (signed int)1); - uint3 fh1((float)1); - uint3 fh2((float)1, (float)1, (float)1); - uint3 fi1((double)1); - uint3 fi2((double)1, (double)1, (double)1); - uint3 fj1((unsigned long)1); - uint3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - uint3 fk1((signed long)1); - uint3 fk2((signed long)1, (signed long)1, (signed long)1); - uint3 fl1((unsigned long long)1); - uint3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - uint3 fm1((signed long long)1); - uint3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestUInt4() { - uint4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (unsigned int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - uint4 fa1((unsigned char)1); - uint4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - uint4 fb1((signed char)1); - uint4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - uint4 fc1((unsigned short)1); - uint4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - uint4 fd1((signed short)1); - uint4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - uint4 fe1((unsigned int)1); - uint4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - uint4 fg1((signed int)1); - uint4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - uint4 fh1((float)1); - uint4 fh2((float)1, (float)1, (float)1, (float)1); - uint4 fi1((double)1); - uint4 fi2((double)1, (double)1, (double)1, (double)1); - uint4 fj1((unsigned long)1); - uint4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - uint4 fk1((signed long)1); - uint4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - uint4 fl1((unsigned long long)1); - uint4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - uint4 fm1((signed long long)1); - uint4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestInt1() { - int1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (signed int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - int1 fa((unsigned char)1); - int1 fb((signed char)1); - int1 fc((unsigned short)1); - int1 fd((signed short)1); - int1 fe((unsigned int)1); - int1 fg((signed int)1); - int1 fh((float)1); - int1 fi((double)1); - int1 fj((unsigned long)1); - int1 fk((signed long)1); - int1 fl((unsigned long long)1); - int1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestInt2() { - int2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (signed int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - int2 fa1((unsigned char)1); - int2 fa2((unsigned char)1, (unsigned char)1); - int2 fb1((signed char)1); - int2 fb2((signed char)1, (signed char)1); - int2 fc1((unsigned short)1); - int2 fc2((unsigned short)1, (unsigned short)1); - int2 fd1((signed short)1); - int2 fd2((signed short)1, (signed short)1); - int2 fe1((unsigned int)1); - int2 fe2((unsigned int)1, (unsigned int)1); - int2 fg1((signed int)1); - int2 fg2((signed int)1, (signed int)1); - int2 fh1((float)1); - int2 fh2((float)1, (float)1); - int2 fi1((double)1); - int2 fi2((double)1, (double)1); - int2 fj1((unsigned long)1); - int2 fj2((unsigned long)1, (unsigned long)1); - int2 fk1((signed long)1); - int2 fk2((signed long)1, (signed long)1); - int2 fl1((unsigned long long)1); - int2 fl2((unsigned long long)1, (unsigned long long)1); - int2 fm1((signed long long)1); - int2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestInt3() { - int3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (signed int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - int3 fa1((unsigned char)1); - int3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - int3 fb1((signed char)1); - int3 fb2((signed char)1, (signed char)1, (signed char)1); - int3 fc1((unsigned short)1); - int3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - int3 fd1((signed short)1); - int3 fd2((signed short)1, (signed short)1, (signed short)1); - int3 fe1((unsigned int)1); - int3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - int3 fg1((signed int)1); - int3 fg2((signed int)1, (signed int)1, (signed int)1); - int3 fh1((float)1); - int3 fh2((float)1, (float)1, (float)1); - int3 fi1((double)1); - int3 fi2((double)1, (double)1, (double)1); - int3 fj1((unsigned long)1); - int3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - int3 fk1((signed long)1); - int3 fk2((signed long)1, (signed long)1, (signed long)1); - int3 fl1((unsigned long long)1); - int3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - int3 fm1((signed long long)1); - int3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestInt4() { - int4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (signed int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - int4 fa1((unsigned char)1); - int4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - int4 fb1((signed char)1); - int4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - int4 fc1((unsigned short)1); - int4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - int4 fd1((signed short)1); - int4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - int4 fe1((unsigned int)1); - int4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - int4 fg1((signed int)1); - int4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - int4 fh1((float)1); - int4 fh2((float)1, (float)1, (float)1, (float)1); - int4 fi1((double)1); - int4 fi2((double)1, (double)1, (double)1, (double)1); - int4 fj1((unsigned long)1); - int4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - int4 fk1((signed long)1); - int4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - int4 fl1((unsigned long long)1); - int4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - int4 fm1((signed long long)1); - int4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestFloat1() { - float1 f1, f2, f3; - f1.x = 1.0f; - f2.x = 1.0f; - f3 = f1 + f2; - cmpVal1(f3, 2.0f); - f2 = f3 - f1; - cmpVal1(f2, 1.0f); - f1 = f2 * f3; - cmpVal1(f1, 2.0f); - f2 = f1 / f3; - cmpVal1(f2, 2.0f / 2.0f); - f1 += f2; - cmpVal1(f1, 3.0f); - f1 -= f2; - cmpVal1(f1, 2.0f); - f1 *= f2; - cmpVal1(f1, 2.0f); - f1 /= f2; - cmpVal1(f1, 2.0f); - f2 = f1++; - cmpVal1(f1, 3.0f); - cmpVal1(f2, 2.0f); - f2 = f1--; - cmpVal1(f2, 3.0f); - cmpVal1(f1, 2.0f); - f2 = ++f1; - cmpVal1(f1, 3.0f); - cmpVal1(f2, 3.0f); - f2 = --f1; - cmpVal1(f1, 2.0f); - cmpVal1(f1, 2.0f); - - f1.x = 3.0f; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3.0f); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3.0f); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3.0f); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3.0f); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3.0f); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3.0f); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (float)1; - cmpVal1(f1, 3.0f); - f1 = (float)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3.0f); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3.0f); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (double)1; - cmpVal1(f1, 3.0f); - f1 = (double)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3.0f); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3.0f); - - float1 fa((unsigned char)1); - float1 fb((signed char)1); - float1 fc((unsigned short)1); - float1 fd((signed short)1); - float1 fe((unsigned int)1); - float1 fg((signed int)1); - float1 fh((float)1); - float1 fi((double)1); - float1 fj((unsigned long)1); - float1 fk((signed long)1); - float1 fl((unsigned long long)1); - float1 fm((signed long long)1); - - - f1.x = 3.0f; - f2.x = 4.0f; - f3.x = 3.0f; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); +template +bool constructor_tests() { + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); return true; } -bool TestFloat2() { - float2 f1, f2, f3; - f1.x = 1.0f; - f1.y = 1.0f; - f2.x = 1.0f; - f2.y = 1.0f; - f3 = f1 + f2; - cmpVal2(f3, 2.0f); +template +bool TestVectorType() { + V f1{1}; + V f2{1}; + V f3 = f1 + f2; + if (f3 != V{2}) return false; f2 = f3 - f1; - cmpVal2(f2, 1.0f); + if (f2 != V{1}) return false; f1 = f2 * f3; - cmpVal2(f1, 2.0f); + if (f1 != V{2}) return false; f2 = f1 / f3; - cmpVal2(f2, 2.0f / 2.0f); + if (f2 != V{1}) return false; + if (!integer_binary_tests(f1, f2, f3)) return false; + + f1 = V{2}; + f2 = V{1}; f1 += f2; - cmpVal2(f1, 3.0f); + if (f1 != V{3}) return false; f1 -= f2; - cmpVal2(f1, 2.0f); + if (f1 != V{2}) return false; f1 *= f2; - cmpVal2(f1, 2.0f); + if (f1 != V{2}) return false; f1 /= f2; - cmpVal2(f1, 2.0f); + if (f1 != V{2}) return false; + if (!integer_unary_tests(f1, f2)) return false; + f1 = V{2}; f2 = f1++; - cmpVal2(f1, 3.0f); - cmpVal2(f2, 2.0f); + if (f1 != V{3}) return false; + if (f2 != V{2}) return false; f2 = f1--; - cmpVal2(f2, 3.0f); - cmpVal2(f1, 2.0f); + if (f2 != V{3}) return false; + if (f1 != V{2}) return false; f2 = ++f1; - cmpVal2(f1, 3.0f); - cmpVal2(f2, 3.0f); + if (f1 != V{3}) return false; + if (f2 != V{3}) return false; f2 = --f1; - cmpVal2(f1, 2.0f); - cmpVal2(f1, 2.0f); + if (f1 != V{2}) return false; + if (f2 != V{2}) return false; - f1.x = 3.0f; - f1.y = 3.0f; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3.0f); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3.0f); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3.0f); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3.0f); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3.0f); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3.0f); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (float)1; - cmpVal2(f1, 3.0f); - f1 = (float)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3.0f); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3.0f); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (double)1; - cmpVal2(f1, 3.0f); - f1 = (double)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3.0f); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3.0f); - - float2 fa1((unsigned char)1); - float2 fa2((unsigned char)1, (unsigned char)1); - float2 fb1((signed char)1); - float2 fb2((signed char)1, (signed char)1); - float2 fc1((unsigned short)1); - float2 fc2((unsigned short)1, (unsigned short)1); - float2 fd1((signed short)1); - float2 fd2((signed short)1, (signed short)1); - float2 fe1((unsigned int)1); - float2 fe2((unsigned int)1, (unsigned int)1); - float2 fg1((signed int)1); - float2 fg2((signed int)1, (signed int)1); - float2 fh1((float)1); - float2 fh2((float)1, (float)1); - float2 fi1((double)1); - float2 fi2((double)1, (double)1); - float2 fj1((unsigned long)1); - float2 fj2((unsigned long)1, (unsigned long)1); - float2 fk1((signed long)1); - float2 fk2((signed long)1, (signed long)1); - float2 fl1((unsigned long long)1); - float2 fl2((unsigned long long)1, (unsigned long long)1); - float2 fm1((signed long long)1); - float2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3.0f; - f1.y = 3.0f; - f2.x = 4.0f; - f2.y = 4.0f; - f3.x = 3.0f; - f3.y = 3.0f; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); + if (!constructor_tests()) return false; + f1 = V{3}; + f2 = V{4}; + f3 = V{3}; + if (f1 == f2) return false; + if (!(f1 != f2)) return false; return true; } -bool TestFloat3() { - float3 f1, f2, f3; - f1.x = 1.0f; - f1.y = 1.0f; - f1.z = 1.0f; - f2.x = 1.0f; - f2.y = 1.0f; - f2.z = 1.0f; - f3 = f1 + f2; - cmpVal3(f3, 2.0f); - f2 = f3 - f1; - cmpVal3(f2, 1.0f); - f1 = f2 * f3; - cmpVal3(f1, 2.0f); - f2 = f1 / f3; - cmpVal3(f2, 2.0f / 2.0f); - f1 += f2; - cmpVal3(f1, 3.0f); - f1 -= f2; - cmpVal3(f1, 2.0f); - f1 *= f2; - cmpVal3(f1, 2.0f); - f1 /= f2; - f2 = f1++; - cmpVal3(f1, 3.0f); - cmpVal3(f2, 2.0f); - f2 = f1--; - cmpVal3(f2, 3.0f); - cmpVal3(f1, 2.0f); - f2 = ++f1; - cmpVal3(f1, 3.0f); - cmpVal3(f2, 3.0f); - f2 = --f1; - cmpVal3(f1, 2.0f); - cmpVal3(f1, 2.0f); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - float3 fa1((unsigned char)1); - float3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - float3 fb1((signed char)1); - float3 fb2((signed char)1, (signed char)1, (signed char)1); - float3 fc1((unsigned short)1); - float3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - float3 fd1((signed short)1); - float3 fd2((signed short)1, (signed short)1, (signed short)1); - float3 fe1((unsigned int)1); - float3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - float3 fg1((signed int)1); - float3 fg2((signed int)1, (signed int)1, (signed int)1); - float3 fh1((float)1); - float3 fh2((float)1, (float)1, (float)1); - float3 fi1((double)1); - float3 fi2((double)1, (double)1, (double)1); - float3 fj1((unsigned long)1); - float3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - float3 fk1((signed long)1); - float3 fk2((signed long)1, (signed long)1, (signed long)1); - float3 fl1((unsigned long long)1); - float3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - float3 fm1((signed long long)1); - float3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3.0f; - f1.y = 3.0f; - f1.z = 3.0f; - f2.x = 4.0f; - f2.y = 4.0f; - f2.z = 4.0f; - f3.x = 3.0f; - f3.y = 3.0f; - f3.z = 3.0f; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - +template* = nullptr> +bool TestVectorTypes() { return true; } -bool TestFloat4() { - float4 f1, f2, f3; - f1.x = 1.0f; - f1.y = 1.0f; - f1.z = 1.0f; - f1.w = 1.0f; - f2.x = 1.0f; - f2.y = 1.0f; - f2.z = 1.0f; - f2.w = 1.0f; - f3 = f1 + f2; - cmpVal4(f3, 2.0f); - f2 = f3 - f1; - cmpVal4(f2, 1.0f); - f1 = f2 * f3; - cmpVal4(f1, 2.0f); - f2 = f1 / f3; - cmpVal4(f2, 2.0f / 2.0f); - f1 += f2; - cmpVal4(f1, 3.0f); - f1 -= f2; - cmpVal4(f1, 2.0f); - f1 *= f2; - cmpVal4(f1, 2.0f); - f1 /= f2; - f2 = f1++; - cmpVal4(f1, 3.0f); - cmpVal4(f2, 2.0f); - f2 = f1--; - cmpVal4(f2, 3.0f); - cmpVal4(f1, 2.0f); - f2 = ++f1; - cmpVal4(f1, 3.0f); - cmpVal4(f2, 3.0f); - f2 = --f1; - cmpVal4(f1, 2.0f); - cmpVal4(f1, 2.0f); - - f1.x = 3.0f; - f1.y = 3.0f; - f1.z = 3.0f; - f1.w = 3.0f; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3.0f); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3.0f); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3.0f); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3.0f); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3.0f); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3.0f); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (float)1; - cmpVal4(f1, 3.0f); - f1 = (float)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3.0f); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3.0f); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (double)1; - cmpVal4(f1, 3.0f); - f1 = (double)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3.0f); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3.0f); - - float4 fa1((unsigned char)1); - float4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - float4 fb1((signed char)1); - float4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - float4 fc1((unsigned short)1); - float4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - float4 fd1((signed short)1); - float4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - float4 fe1((unsigned int)1); - float4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - float4 fg1((signed int)1); - float4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - float4 fh1((float)1); - float4 fh2((float)1, (float)1, (float)1, (float)1); - float4 fi1((double)1); - float4 fi2((double)1, (double)1, (double)1, (double)1); - float4 fj1((unsigned long)1); - float4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - float4 fk1((signed long)1); - float4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - float4 fl1((unsigned long long)1); - float4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - float4 fm1((signed long long)1); - float4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3.0f; - f1.y = 3.0f; - f1.z = 3.0f; - f1.w = 3.0f; - f2.x = 4.0f; - f2.y = 4.0f; - f2.z = 4.0f; - f2.w = 4.0f; - f3.x = 3.0f; - f3.y = 3.0f; - f3.z = 3.0f; - f3.w = 3.0f; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - return true; +template +bool TestVectorTypes() { + if (!TestVectorType()) return false; + return TestVectorTypes(); } - -bool TestULong1() { - ulong1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, 18446744073709551613UL); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - ulong1 fa((unsigned char)1); - ulong1 fb((signed char)1); - ulong1 fc((unsigned short)1); - ulong1 fd((signed short)1); - ulong1 fe((unsigned int)1); - ulong1 fg((signed int)1); - ulong1 fh((float)1); - ulong1 fi((double)1); - ulong1 fj((unsigned long)1); - ulong1 fk((signed long)1); - ulong1 fl((unsigned long long)1); - ulong1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestULong2() { - ulong2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, 18446744073709551613UL); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - ulong2 fa1((unsigned char)1); - ulong2 fa2((unsigned char)1, (unsigned char)1); - ulong2 fb1((signed char)1); - ulong2 fb2((signed char)1, (signed char)1); - ulong2 fc1((unsigned short)1); - ulong2 fc2((unsigned short)1, (unsigned short)1); - ulong2 fd1((signed short)1); - ulong2 fd2((signed short)1, (signed short)1); - ulong2 fe1((unsigned int)1); - ulong2 fe2((unsigned int)1, (unsigned int)1); - ulong2 fg1((signed int)1); - ulong2 fg2((signed int)1, (signed int)1); - ulong2 fh1((float)1); - ulong2 fh2((float)1, (float)1); - ulong2 fi1((double)1); - ulong2 fi2((double)1, (double)1); - ulong2 fj1((unsigned long)1); - ulong2 fj2((unsigned long)1, (unsigned long)1); - ulong2 fk1((signed long)1); - ulong2 fk2((signed long)1, (signed long)1); - ulong2 fl1((unsigned long long)1); - ulong2 fl2((unsigned long long)1, (unsigned long long)1); - ulong2 fm1((signed long long)1); - ulong2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestULong3() { - ulong3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, 18446744073709551613UL); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - ulong3 fa1((unsigned char)1); - ulong3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - ulong3 fb1((signed char)1); - ulong3 fb2((signed char)1, (signed char)1, (signed char)1); - ulong3 fc1((unsigned short)1); - ulong3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - ulong3 fd1((signed short)1); - ulong3 fd2((signed short)1, (signed short)1, (signed short)1); - ulong3 fe1((unsigned int)1); - ulong3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - ulong3 fg1((signed int)1); - ulong3 fg2((signed int)1, (signed int)1, (signed int)1); - ulong3 fh1((float)1); - ulong3 fh2((float)1, (float)1, (float)1); - ulong3 fi1((double)1); - ulong3 fi2((double)1, (double)1, (double)1); - ulong3 fj1((unsigned long)1); - ulong3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - ulong3 fk1((signed long)1); - ulong3 fk2((signed long)1, (signed long)1, (signed long)1); - ulong3 fl1((unsigned long long)1); - ulong3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - ulong3 fm1((signed long long)1); - ulong3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestULong4() { - ulong4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, 18446744073709551613UL); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - ulong4 fa1((unsigned char)1); - ulong4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - ulong4 fb1((signed char)1); - ulong4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - ulong4 fc1((unsigned short)1); - ulong4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - ulong4 fd1((signed short)1); - ulong4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - ulong4 fe1((unsigned int)1); - ulong4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - ulong4 fg1((signed int)1); - ulong4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - ulong4 fh1((float)1); - ulong4 fh2((float)1, (float)1, (float)1, (float)1); - ulong4 fi1((double)1); - ulong4 fi2((double)1, (double)1, (double)1, (double)1); - ulong4 fj1((unsigned long)1); - ulong4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - ulong4 fk1((signed long)1); - ulong4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - ulong4 fl1((unsigned long long)1); - ulong4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - ulong4 fm1((signed long long)1); - ulong4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestLong1() { - long1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - long1 fa((unsigned char)1); - long1 fb((signed char)1); - long1 fc((unsigned short)1); - long1 fd((signed short)1); - long1 fe((unsigned int)1); - long1 fg((signed int)1); - long1 fh((float)1); - long1 fi((double)1); - long1 fj((unsigned long)1); - long1 fk((signed long)1); - long1 fl((unsigned long long)1); - long1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestLong2() { - long2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - long2 fa1((unsigned char)1); - long2 fa2((unsigned char)1, (unsigned char)1); - long2 fb1((signed char)1); - long2 fb2((signed char)1, (signed char)1); - long2 fc1((unsigned short)1); - long2 fc2((unsigned short)1, (unsigned short)1); - long2 fd1((signed short)1); - long2 fd2((signed short)1, (signed short)1); - long2 fe1((unsigned int)1); - long2 fe2((unsigned int)1, (unsigned int)1); - long2 fg1((signed int)1); - long2 fg2((signed int)1, (signed int)1); - long2 fh1((float)1); - long2 fh2((float)1, (float)1); - long2 fi1((double)1); - long2 fi2((double)1, (double)1); - long2 fj1((unsigned long)1); - long2 fj2((unsigned long)1, (unsigned long)1); - long2 fk1((signed long)1); - long2 fk2((signed long)1, (signed long)1); - long2 fl1((unsigned long long)1); - long2 fl2((unsigned long long)1, (unsigned long long)1); - long2 fm1((signed long long)1); - long2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestLong3() { - long3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - - long3 fa1((unsigned char)1); - long3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - long3 fb1((signed char)1); - long3 fb2((signed char)1, (signed char)1, (signed char)1); - long3 fc1((unsigned short)1); - long3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - long3 fd1((signed short)1); - long3 fd2((signed short)1, (signed short)1, (signed short)1); - long3 fe1((unsigned int)1); - long3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - long3 fg1((signed int)1); - long3 fg2((signed int)1, (signed int)1, (signed int)1); - long3 fh1((float)1); - long3 fh2((float)1, (float)1, (float)1); - long3 fi1((double)1); - long3 fi2((double)1, (double)1, (double)1); - long3 fj1((unsigned long)1); - long3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - long3 fk1((signed long)1); - long3 fk2((signed long)1, (signed long)1, (signed long)1); - long3 fl1((unsigned long long)1); - long3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - long3 fm1((signed long long)1); - long3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestLong4() { - long4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - long4 fa1((unsigned char)1); - long4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - long4 fb1((signed char)1); - long4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - long4 fc1((unsigned short)1); - long4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - long4 fd1((signed short)1); - long4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - long4 fe1((unsigned int)1); - long4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - long4 fg1((signed int)1); - long4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - long4 fh1((float)1); - long4 fh2((float)1, (float)1, (float)1, (float)1); - long4 fi1((double)1); - long4 fi2((double)1, (double)1, (double)1, (double)1); - long4 fj1((unsigned long)1); - long4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - long4 fk1((signed long)1); - long4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - long4 fl1((unsigned long long)1); - long4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - long4 fm1((signed long long)1); - long4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestDouble1() { - double1 f1, f2, f3; - f1.x = 1.0; - f2.x = 1.0; - f3 = f1 + f2; - cmpVal1(f3, 2.0); - f2 = f3 - f1; - cmpVal1(f2, 1.0); - f1 = f2 * f3; - cmpVal1(f1, 2.0); - f2 = f1 / f3; - cmpVal1(f2, 2.0 / 2.0); - f1 += f2; - cmpVal1(f1, 3.0); - f1 -= f2; - cmpVal1(f1, 2.0); - f1 *= f2; - cmpVal1(f1, 2.0); - f1 /= f2; - cmpVal1(f1, 2.0); - f2 = f1++; - cmpVal1(f1, 3.0); - cmpVal1(f2, 2.0); - f2 = f1--; - cmpVal1(f2, 3.0); - cmpVal1(f1, 2.0); - f2 = ++f1; - cmpVal1(f1, 3.0); - cmpVal1(f2, 3.0); - f2 = --f1; - cmpVal1(f1, 2.0); - cmpVal1(f1, 2.0); - - f1.x = 3.0; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3.0); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3.0); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3.0); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3.0); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3.0); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3.0); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (float)1; - cmpVal1(f1, 3.0); - f1 = (float)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3.0); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3.0); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (double)1; - cmpVal1(f1, 3.0); - f1 = (double)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3.0); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3.0); - - double1 fa((unsigned char)1); - double1 fb((signed char)1); - double1 fc((unsigned short)1); - double1 fd((signed short)1); - double1 fe((unsigned int)1); - double1 fg((signed int)1); - double1 fh((float)1); - double1 fi((double)1); - double1 fj((unsigned long)1); - double1 fk((signed long)1); - double1 fl((unsigned long long)1); - double1 fm((signed long long)1); - - - f1.x = 3.0; - f2.x = 4.0; - f3.x = 3.0; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - return true; -} - -bool TestDouble2() { - double2 f1, f2, f3; - f1.x = 1.0; - f1.y = 1.0; - f2.x = 1.0; - f2.y = 1.0; - f3 = f1 + f2; - cmpVal2(f3, 2.0); - f2 = f3 - f1; - cmpVal2(f2, 1.0); - f1 = f2 * f3; - cmpVal2(f1, 2.0); - f2 = f1 / f3; - cmpVal2(f2, 2.0f / 2.0); - f1 += f2; - cmpVal2(f1, 3.0); - f1 -= f2; - cmpVal2(f1, 2.0); - f1 *= f2; - cmpVal2(f1, 2.0); - f1 /= f2; - cmpVal2(f1, 2.0); - - f2 = f1++; - cmpVal2(f1, 3.0); - cmpVal2(f2, 2.0); - f2 = f1--; - cmpVal2(f2, 3.0); - cmpVal2(f1, 2.0); - f2 = ++f1; - cmpVal2(f1, 3.0); - cmpVal2(f2, 3.0); - f2 = --f1; - cmpVal2(f1, 2.0); - cmpVal2(f1, 2.0); - - f1.x = 3.0; - f1.y = 3.0; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3.0); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3.0); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3.0); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3.0); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3.0); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3.0); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (float)1; - cmpVal2(f1, 3.0); - f1 = (float)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3.0); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3.0); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (double)1; - cmpVal2(f1, 3.0); - f1 = (double)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3.0); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3.0); - - double2 fa1((unsigned char)1); - double2 fa2((unsigned char)1, (unsigned char)1); - double2 fb1((signed char)1); - double2 fb2((signed char)1, (signed char)1); - double2 fc1((unsigned short)1); - double2 fc2((unsigned short)1, (unsigned short)1); - double2 fd1((signed short)1); - double2 fd2((signed short)1, (signed short)1); - double2 fe1((unsigned int)1); - double2 fe2((unsigned int)1, (unsigned int)1); - double2 fg1((signed int)1); - double2 fg2((signed int)1, (signed int)1); - double2 fh1((float)1); - double2 fh2((float)1, (float)1); - double2 fi1((double)1); - double2 fi2((double)1, (double)1); - double2 fj1((unsigned long)1); - double2 fj2((unsigned long)1, (unsigned long)1); - double2 fk1((signed long)1); - double2 fk2((signed long)1, (signed long)1); - double2 fl1((unsigned long long)1); - double2 fl2((unsigned long long)1, (unsigned long long)1); - double2 fm1((signed long long)1); - double2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3.0; - f1.y = 3.0; - f2.x = 4.0; - f2.y = 4.0; - f3.x = 3.0; - f3.y = 3.0; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - - return true; -} - -bool TestDouble3() { - double3 f1, f2, f3; - f1.x = 1.0; - f1.y = 1.0; - f1.z = 1.0; - f2.x = 1.0; - f2.y = 1.0; - f2.z = 1.0; - f3 = f1 + f2; - cmpVal3(f3, 2.0); - f2 = f3 - f1; - cmpVal3(f2, 1.0); - f1 = f2 * f3; - cmpVal3(f1, 2.0); - f2 = f1 / f3; - cmpVal3(f2, 2.0f / 2.0); - f1 += f2; - cmpVal3(f1, 3.0); - f1 -= f2; - cmpVal3(f1, 2.0); - f1 *= f2; - cmpVal3(f1, 2.0); - f1 /= f2; - f2 = f1++; - cmpVal3(f1, 3.0); - cmpVal3(f2, 2.0); - f2 = f1--; - cmpVal3(f2, 3.0); - cmpVal3(f1, 2.0); - f2 = ++f1; - cmpVal3(f1, 3.0); - cmpVal3(f2, 3.0); - f2 = --f1; - cmpVal3(f1, 2.0); - cmpVal3(f1, 2.0); - - f1.x = 3.0; - f1.y = 3.0; - f1.z = 3.0; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3.0); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3.0); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3.0); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3.0); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3.0); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3.0); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (float)1; - cmpVal3(f1, 3.0); - f1 = (float)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3.0); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3.0); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (double)1; - cmpVal3(f1, 3.0); - f1 = (double)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3.0); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3.0); - - double3 fa1((unsigned char)1); - double3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - double3 fb1((signed char)1); - double3 fb2((signed char)1, (signed char)1, (signed char)1); - double3 fc1((unsigned short)1); - double3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - double3 fd1((signed short)1); - double3 fd2((signed short)1, (signed short)1, (signed short)1); - double3 fe1((unsigned int)1); - double3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - double3 fg1((signed int)1); - double3 fg2((signed int)1, (signed int)1, (signed int)1); - double3 fh1((float)1); - double3 fh2((float)1, (float)1, (float)1); - double3 fi1((double)1); - double3 fi2((double)1, (double)1, (double)1); - double3 fj1((unsigned long)1); - double3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - double3 fk1((signed long)1); - double3 fk2((signed long)1, (signed long)1, (signed long)1); - double3 fl1((unsigned long long)1); - double3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - double3 fm1((signed long long)1); - double3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3.0; - f1.y = 3.0; - f1.z = 3.0; - f2.x = 4.0; - f2.y = 4.0; - f2.z = 4.0; - f3.x = 3.0; - f3.y = 3.0; - f3.z = 3.0; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - - return true; -} - -bool TestDouble4() { - double4 f1, f2, f3; - f1.x = 1.0; - f1.y = 1.0; - f1.z = 1.0; - f1.w = 1.0; - f2.x = 1.0; - f2.y = 1.0; - f2.z = 1.0; - f2.w = 1.0; - f3 = f1 + f2; - cmpVal4(f3, 2.0); - f2 = f3 - f1; - cmpVal4(f2, 1.0); - f1 = f2 * f3; - cmpVal4(f1, 2.0); - f2 = f1 / f3; - cmpVal4(f2, 2.0f / 2.0); - f1 += f2; - cmpVal4(f1, 3.0); - f1 -= f2; - cmpVal4(f1, 2.0); - f1 *= f2; - cmpVal4(f1, 2.0); - f1 /= f2; - f2 = f1++; - cmpVal4(f1, 3.0); - cmpVal4(f2, 2.0); - f2 = f1--; - cmpVal4(f2, 3.0); - cmpVal4(f1, 2.0); - f2 = ++f1; - cmpVal4(f1, 3.0); - cmpVal4(f2, 3.0); - f2 = --f1; - cmpVal4(f1, 2.0); - cmpVal4(f1, 2.0); - - f1.x = 3.0; - f1.y = 3.0; - f1.z = 3.0; - f1.w = 3.0; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3.0); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3.0); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3.0); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3.0); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3.0); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3.0); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (float)1; - cmpVal4(f1, 3.0); - f1 = (float)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3.0); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3.0); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (double)1; - cmpVal4(f1, 3.0); - f1 = (double)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3.0); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3.0); - - double4 fa1((unsigned char)1); - double4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - double4 fb1((signed char)1); - double4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - double4 fc1((unsigned short)1); - double4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - double4 fd1((signed short)1); - double4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - double4 fe1((unsigned int)1); - double4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - double4 fg1((signed int)1); - double4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - double4 fh1((float)1); - double4 fh2((float)1, (float)1, (float)1, (float)1); - double4 fi1((double)1); - double4 fi2((double)1, (double)1, (double)1, (double)1); - double4 fj1((unsigned long)1); - double4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - double4 fk1((signed long)1); - double4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - double4 fl1((unsigned long long)1); - double4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - double4 fm1((signed long long)1); - double4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3.0; - f1.y = 3.0; - f1.z = 3.0; - f1.w = 3.0; - f2.x = 4.0; - f2.y = 4.0; - f2.z = 4.0; - f2.w = 4.0; - f3.x = 3.0; - f3.y = 3.0; - f3.z = 3.0; - f3.w = 3.0; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - return true; -} - - -bool TestULongLong1() { - long1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - ulonglong1 fa((unsigned char)1); - ulonglong1 fb((signed char)1); - ulonglong1 fc((unsigned short)1); - ulonglong1 fd((signed short)1); - ulonglong1 fe((unsigned int)1); - ulonglong1 fg((signed int)1); - ulonglong1 fh((float)1); - ulonglong1 fi((double)1); - ulonglong1 fj((unsigned long)1); - ulonglong1 fk((signed long)1); - ulonglong1 fl((unsigned long long)1); - ulonglong1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestULongLong2() { - long2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - ulonglong2 fa1((unsigned char)1); - ulonglong2 fa2((unsigned char)1, (unsigned char)1); - ulonglong2 fb1((signed char)1); - ulonglong2 fb2((signed char)1, (signed char)1); - ulonglong2 fc1((unsigned short)1); - ulonglong2 fc2((unsigned short)1, (unsigned short)1); - ulonglong2 fd1((signed short)1); - ulonglong2 fd2((signed short)1, (signed short)1); - ulonglong2 fe1((unsigned int)1); - ulonglong2 fe2((unsigned int)1, (unsigned int)1); - ulonglong2 fg1((signed int)1); - ulonglong2 fg2((signed int)1, (signed int)1); - ulonglong2 fh1((float)1); - ulonglong2 fh2((float)1, (float)1); - ulonglong2 fi1((double)1); - ulonglong2 fi2((double)1, (double)1); - ulonglong2 fj1((unsigned long)1); - ulonglong2 fj2((unsigned long)1, (unsigned long)1); - ulonglong2 fk1((signed long)1); - ulonglong2 fk2((signed long)1, (signed long)1); - ulonglong2 fl1((unsigned long long)1); - ulonglong2 fl2((unsigned long long)1, (unsigned long long)1); - ulonglong2 fm1((signed long long)1); - ulonglong2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestULongLong3() { - long3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - ulonglong3 fa1((unsigned char)1); - ulonglong3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - ulonglong3 fb1((signed char)1); - ulonglong3 fb2((signed char)1, (signed char)1, (signed char)1); - ulonglong3 fc1((unsigned short)1); - ulonglong3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - ulonglong3 fd1((signed short)1); - ulonglong3 fd2((signed short)1, (signed short)1, (signed short)1); - ulonglong3 fe1((unsigned int)1); - ulonglong3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - ulonglong3 fg1((signed int)1); - ulonglong3 fg2((signed int)1, (signed int)1, (signed int)1); - ulonglong3 fh1((float)1); - ulonglong3 fh2((float)1, (float)1, (float)1); - ulonglong3 fi1((double)1); - ulonglong3 fi2((double)1, (double)1, (double)1); - ulonglong3 fj1((unsigned long)1); - ulonglong3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - ulonglong3 fk1((signed long)1); - ulonglong3 fk2((signed long)1, (signed long)1, (signed long)1); - ulonglong3 fl1((unsigned long long)1); - ulonglong3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - ulonglong3 fm1((signed long long)1); - ulonglong3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestULongLong4() { - long4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - ulonglong4 fa1((unsigned char)1); - ulonglong4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - ulonglong4 fb1((signed char)1); - ulonglong4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - ulonglong4 fc1((unsigned short)1); - ulonglong4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - ulonglong4 fd1((signed short)1); - ulonglong4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - ulonglong4 fe1((unsigned int)1); - ulonglong4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - ulonglong4 fg1((signed int)1); - ulonglong4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - ulonglong4 fh1((float)1); - ulonglong4 fh2((float)1, (float)1, (float)1, (float)1); - ulonglong4 fi1((double)1); - ulonglong4 fi2((double)1, (double)1, (double)1, (double)1); - ulonglong4 fj1((unsigned long)1); - ulonglong4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - ulonglong4 fk1((signed long)1); - ulonglong4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - ulonglong4 fl1((unsigned long long)1); - ulonglong4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - ulonglong4 fm1((signed long long)1); - ulonglong4 fm2((signed long long)1, (signed long long)1, (signed long long)1, - (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestLongLong1() { - long1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - longlong1 fa((unsigned char)1); - longlong1 fb((signed char)1); - longlong1 fc((unsigned short)1); - longlong1 fd((signed short)1); - longlong1 fe((unsigned int)1); - longlong1 fg((signed int)1); - longlong1 fh((float)1); - longlong1 fi((double)1); - longlong1 fj((unsigned long)1); - longlong1 fk((signed long)1); - longlong1 fl((unsigned long long)1); - longlong1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestLongLong2() { - long2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - longlong2 fa1((unsigned char)1); - longlong2 fa2((unsigned char)1, (unsigned char)1); - longlong2 fb1((signed char)1); - longlong2 fb2((signed char)1, (signed char)1); - longlong2 fc1((unsigned short)1); - longlong2 fc2((unsigned short)1, (unsigned short)1); - longlong2 fd1((signed short)1); - longlong2 fd2((signed short)1, (signed short)1); - longlong2 fe1((unsigned int)1); - longlong2 fe2((unsigned int)1, (unsigned int)1); - longlong2 fg1((signed int)1); - longlong2 fg2((signed int)1, (signed int)1); - longlong2 fh1((float)1); - longlong2 fh2((float)1, (float)1); - longlong2 fi1((double)1); - longlong2 fi2((double)1, (double)1); - longlong2 fj1((unsigned long)1); - longlong2 fj2((unsigned long)1, (unsigned long)1); - longlong2 fk1((signed long)1); - longlong2 fk2((signed long)1, (signed long)1); - longlong2 fl1((unsigned long long)1); - longlong2 fl2((unsigned long long)1, (unsigned long long)1); - longlong2 fm1((signed long long)1); - longlong2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestLongLong3() { - long3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - longlong3 fa1((unsigned char)1); - longlong3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - longlong3 fb1((signed char)1); - longlong3 fb2((signed char)1, (signed char)1, (signed char)1); - longlong3 fc1((unsigned short)1); - longlong3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - longlong3 fd1((signed short)1); - longlong3 fd2((signed short)1, (signed short)1, (signed short)1); - longlong3 fe1((unsigned int)1); - longlong3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - longlong3 fg1((signed int)1); - longlong3 fg2((signed int)1, (signed int)1, (signed int)1); - longlong3 fh1((float)1); - longlong3 fh2((float)1, (float)1, (float)1); - longlong3 fi1((double)1); - longlong3 fi2((double)1, (double)1, (double)1); - longlong3 fj1((unsigned long)1); - longlong3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - longlong3 fk1((signed long)1); - longlong3 fk2((signed long)1, (signed long)1, (signed long)1); - longlong3 fl1((unsigned long long)1); - longlong3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - longlong3 fm1((signed long long)1); - longlong3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestLongLong4() { - long4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - longlong4 fa1((unsigned char)1); - longlong4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - longlong4 fb1((signed char)1); - longlong4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - longlong4 fc1((unsigned short)1); - longlong4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - longlong4 fd1((signed short)1); - longlong4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - longlong4 fe1((unsigned int)1); - longlong4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - longlong4 fg1((signed int)1); - longlong4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - longlong4 fh1((float)1); - longlong4 fh2((float)1, (float)1, (float)1, (float)1); - longlong4 fi1((double)1); - longlong4 fi2((double)1, (double)1, (double)1, (double)1); - longlong4 fj1((unsigned long)1); - longlong4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - longlong4 fk1((signed long)1); - longlong4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - longlong4 fl1((unsigned long long)1); - longlong4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - longlong4 fm1((signed long long)1); - longlong4 fm2((signed long long)1, (signed long long)1, (signed long long)1, - (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; +bool CheckVectorTypes() { + return TestVectorTypes< + char1, char2, char3, char4, + uchar1, uchar2, uchar3, uchar4, + short1, short2, short3, short4, + ushort1, ushort2, ushort3, ushort4, + int1, int2, int3, int4, + uint1, uint2, uint3, uint4, + long1, long2, long3, long4, + ulong1, ulong2, ulong3, ulong4, + longlong1, longlong2, longlong3, longlong4, + ulonglong1, ulonglong2, ulonglong3, ulonglong4, + float1, float2, float3, float4, + double1, double2, double3, double4>(); } int main() { - assert(sizeof(float1) == 4); - assert(sizeof(float2) == 8); - assert(sizeof(float3) == 12); - assert(sizeof(float4) == 16); - assert(TestFloat1() && TestFloat2() && TestFloat3() && TestFloat4() && TestDouble1() && - TestDouble2() && TestDouble3() && TestDouble4() && TestUChar1() && TestUChar2() && - TestUChar3() && TestUChar4() && TestChar1() && TestChar2() && TestChar3() && - TestChar4() && TestUShort1() && TestUShort2() && TestUShort3() && TestUShort4() && - TestShort1() && TestShort2() && TestShort3() && TestShort4() && TestUInt1() && - TestUInt2() && TestUInt3() && TestUInt4() && TestInt1() && TestInt2() && TestInt3() && - TestInt4() && TestULong1() && TestULong2() && TestULong3() && TestULong4() && - TestLong1() && TestLong2() && TestLong3() && TestLong4() && TestULongLong1() && - TestULongLong2() && TestULongLong3() && TestULongLong4() && TestLongLong1() && - TestLongLong2() && TestLongLong3() && TestLongLong4() == true); - passed(); - float1 f1 = make_float1(1.0f); -} + static_assert(sizeof(float1) == 4, ""); + static_assert(sizeof(float2) >= 8, ""); + static_assert(sizeof(float3) >= 12, ""); + static_assert(sizeof(float4) >= 16, ""); + + if (CheckVectorTypes()) { + float1 f1 = make_float1(1.0f); + passed(); + } + else { + failed("Failed some vector test on the host side."); + } +} \ No newline at end of file diff --git a/projects/hip/tests/src/deviceLib/hipVectorTypesDevice.cpp b/projects/hip/tests/src/deviceLib/hipVectorTypesDevice.cpp index 24ac3f4a02..03e8158a4e 100644 --- a/projects/hip/tests/src/deviceLib/hipVectorTypesDevice.cpp +++ b/projects/hip/tests/src/deviceLib/hipVectorTypesDevice.cpp @@ -26,4212 +26,177 @@ THE SOFTWARE. * HIT_END */ -#include #include + +#include "vector_test_common.h" #include "test_common.h" -#define cmpVal1(in, exp) \ - if (in.x != exp) { \ - } -#define cmpVal2(in, exp) \ - if (in.x != exp || in.y != exp) { \ - } +#include +#include +#include -#define cmpVal3(in, exp) \ - if (in.x != exp || in.y != exp || in.z != exp) { \ - } +using namespace std; -#define cmpVal4(in, exp) \ - if (in.x != exp || in.y != exp || in.z != exp || in.w != exp) { \ - } +template< + typename V, + Enable_if_t().x)>{}>* = nullptr> +constexpr +bool integer_unary_tests(const V&, const V&) { + return true; +} -__device__ bool TestUChar1() { - uchar1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); +template< + typename V, + Enable_if_t().x)>{}>* = nullptr> +__device__ +bool integer_unary_tests(V& f1, V& f2) { f1 %= f2; - cmpVal1(f1, 0); + if (f1 != V{0}) return false; + f1 &= f2; - cmpVal1(f1, 0); + if (f1 != V{0}) return false; f1 |= f2; - cmpVal1(f1, 1); + if (f1 != V{1}) return false; f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; + if (f1 != V{0}) return false; + f1 = V{1}; f1 <<= f2; - cmpVal1(f1, 2); + if (f1 != V{2}) return false; f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - + if (f1 != V{1}) return false; f2 = ~f1; - cmpVal1(f2, 253); + return f2 == V{~1}; - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - - // signed char sc = 1; - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } return true; } -__device__ bool TestUChar2() { - uchar2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); +template< + typename V, + Enable_if_t().x)>{}>* = nullptr> +constexpr +bool integer_binary_tests(const V&, const V&, const V&) { + return true; +} + +template< + typename V, + Enable_if_t().x)>{}>* = nullptr> +__device__ +bool integer_binary_tests(V& f1, V& f2, V& f3) { f3 = f1 % f2; - cmpVal2(f3, 0); + if (f3 != V{0}) return false; f1 = f3 & f2; - cmpVal2(f1, 0); + if (f1 != V{0}) return false; f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; + if (f2 != V{0}) return false; + f1 = V{1}; + f2 = V{2}; f3 = f1 << f2; - cmpVal2(f3, 4); + if (f3 != V{4}) return false; f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, 253); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; + return f2 == V{2}; } -__device__ bool TestUChar3() { - uchar3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); +template +__device__ +bool TestVectorType() { + V f1{1}; + V f2{1}; + V f3 = f1 + f2; + if (f3 != V{2}) return false; f2 = f3 - f1; - cmpVal3(f2, 1); + if (f2 != V{1}) return false; f1 = f2 * f3; - cmpVal3(f1, 2); + if (f1 != V{2}) return false; f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); + if (f2 != V{1}) return false; + if (!integer_binary_tests(f1, f2, f3)) return false; - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; + f1 = V{2}; + f2 = V{1}; f1 += f2; - cmpVal3(f1, 3); + if (f1 != V{3}) return false; f1 -= f2; - cmpVal3(f1, 2); + if (f1 != V{2}) return false; f1 *= f2; - cmpVal3(f1, 2); + if (f1 != V{2}) return false; f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); + if (f1 != V{2}) return false; + if (!integer_unary_tests(f1, f2)) return false; - f1.x = 2; - f1.y = 2; - f1.z = 2; + f1 = V{2}; f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); + if (f1 != V{3}) return false; + if (f2 != V{2}) return false; f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); + if (f2 != V{3}) return false; + if (f1 != V{2}) return false; f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); + if (f1 != V{3}) return false; + if (f2 != V{3}) return false; f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, 253); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUChar4() { - uchar4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, 253); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestChar1() { - char1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (char)253); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestChar2() { - char2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (char)253); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestChar3() { - char3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (char)253); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestChar4() { - char4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (char)253); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUShort1() { - ushort1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (unsigned short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUShort2() { - ushort2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (unsigned short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUShort3() { - ushort3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (unsigned short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUShort4() { - ushort4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (unsigned short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestShort1() { - short1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (signed short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestShort2() { - short2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (signed short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestShort3() { - short3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (signed short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestShort4() { - short4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (signed short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - - -__device__ bool TestUInt1() { - uint1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (unsigned int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUInt2() { - uint2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (unsigned int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUInt3() { - uint3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (unsigned int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUInt4() { - uint4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (unsigned int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestInt1() { - int1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (signed int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestInt2() { - int2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (signed int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestInt3() { - int3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (signed int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestInt4() { - int4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (signed int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestULong1() { - ulong1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, 18446744073709551613UL); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestULong2() { - ulong2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, 18446744073709551613UL); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestULong3() { - ulong3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, 18446744073709551613UL); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestULong4() { - ulong4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, 18446744073709551613UL); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestLong1() { - long1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestLong2() { - long2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestLong3() { - long3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestLong4() { - long4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - - -__device__ bool TestFloat1() { - float1 f1, f2, f3; - // float1 f4(1); - // cmpVal1(f4, 1.0f); - // float1 f5(2.0f); - // cmpVal1(f5, 2.0f); - f1.x = 1.0f; - f2.x = 1.0f; - f3 = f1 + f2; - cmpVal1(f3, 2.0f); - f2 = f3 - f1; - cmpVal1(f2, 1.0f); - f1 = f2 * f3; - cmpVal1(f1, 2.0f); - f2 = f1 / f3; - cmpVal1(f2, 2.0f / 2.0f); - f1 += f2; - cmpVal1(f1, 3.0f); - f1 -= f2; - cmpVal1(f1, 2.0f); - f1 *= f2; - cmpVal1(f1, 2.0f); - f1 /= f2; - cmpVal1(f1, 2.0f); - f2 = f1++; - cmpVal1(f1, 3.0f); - cmpVal1(f2, 2.0f); - f2 = f1--; - cmpVal1(f2, 3.0f); - cmpVal1(f1, 2.0f); - f2 = ++f1; - cmpVal1(f1, 3.0f); - cmpVal1(f2, 3.0f); - f2 = --f1; - cmpVal1(f1, 2.0f); - cmpVal1(f1, 2.0f); - - f1.x = 3.0f; - f2.x = 4.0f; - f3.x = 3.0f; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } + if (f1 != V{2}) return false; + if (f2 != V{2}) return false; + + f1 = V{3}; + f2 = V{4}; + f3 = V{3}; + if (f1 == f2) return false; + if (!(f1 != f2)) return false; return true; } -__device__ bool TestFloat2() { - float2 f1, f2, f3; - f1.x = 1.0f; - f1.y = 1.0f; - f2.x = 1.0f; - f2.y = 1.0f; - f3 = f1 + f2; - cmpVal2(f3, 2.0f); - f2 = f3 - f1; - cmpVal2(f2, 1.0f); - f1 = f2 * f3; - cmpVal2(f1, 2.0f); - f2 = f1 / f3; - cmpVal2(f2, 2.0f / 2.0f); - f1 += f2; - cmpVal2(f1, 3.0f); - f1 -= f2; - cmpVal2(f1, 2.0f); - f1 *= f2; - cmpVal2(f1, 2.0f); - f1 /= f2; - cmpVal2(f1, 2.0f); - - f2 = f1++; - cmpVal2(f1, 3.0f); - cmpVal2(f2, 2.0f); - f2 = f1--; - cmpVal2(f2, 3.0f); - cmpVal2(f1, 2.0f); - f2 = ++f1; - cmpVal2(f1, 3.0f); - cmpVal2(f2, 3.0f); - f2 = --f1; - cmpVal2(f1, 2.0f); - cmpVal2(f1, 2.0f); - - f1.x = 3.0f; - f1.y = 3.0f; - f2.x = 4.0f; - f2.y = 4.0f; - f3.x = 3.0f; - f3.y = 3.0f; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - +template* = nullptr> +__device__ +bool TestVectorTypes() { return true; } -__device__ bool TestFloat3() { - float3 f1, f2, f3; - f1.x = 1.0f; - f1.y = 1.0f; - f1.z = 1.0f; - f2.x = 1.0f; - f2.y = 1.0f; - f2.z = 1.0f; - f3 = f1 + f2; - cmpVal3(f3, 2.0f); - f2 = f3 - f1; - cmpVal3(f2, 1.0f); - f1 = f2 * f3; - cmpVal3(f1, 2.0f); - f2 = f1 / f3; - cmpVal3(f2, 2.0f / 2.0f); - f1 += f2; - cmpVal3(f1, 3.0f); - f1 -= f2; - cmpVal3(f1, 2.0f); - f1 *= f2; - cmpVal3(f1, 2.0f); - f1 /= f2; - f2 = f1++; - cmpVal3(f1, 3.0f); - cmpVal3(f2, 2.0f); - f2 = f1--; - cmpVal3(f2, 3.0f); - cmpVal3(f1, 2.0f); - f2 = ++f1; - cmpVal3(f1, 3.0f); - cmpVal3(f2, 3.0f); - f2 = --f1; - cmpVal3(f1, 2.0f); - cmpVal3(f1, 2.0f); - - f1.x = 3.0f; - f1.y = 3.0f; - f1.z = 3.0f; - f2.x = 4.0f; - f2.y = 4.0f; - f2.z = 4.0f; - f3.x = 3.0f; - f3.y = 3.0f; - f3.z = 3.0f; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - - return true; +template +__device__ +bool TestVectorTypes() { + if (!TestVectorType()) return false; + return TestVectorTypes(); } - -__device__ bool TestFloat4() { - float4 f1, f2, f3; - f1.x = 1.0f; - f1.y = 1.0f; - f1.z = 1.0f; - f1.w = 1.0f; - f2.x = 1.0f; - f2.y = 1.0f; - f2.z = 1.0f; - f2.w = 1.0f; - f3 = f1 + f2; - cmpVal4(f3, 2.0f); - f2 = f3 - f1; - cmpVal4(f2, 1.0f); - f1 = f2 * f3; - cmpVal4(f1, 2.0f); - f2 = f1 / f3; - cmpVal4(f2, 2.0f / 2.0f); - f1 += f2; - cmpVal4(f1, 3.0f); - f1 -= f2; - cmpVal4(f1, 2.0f); - f1 *= f2; - cmpVal4(f1, 2.0f); - f1 /= f2; - f2 = f1++; - cmpVal4(f1, 3.0f); - cmpVal4(f2, 2.0f); - f2 = f1--; - cmpVal4(f2, 3.0f); - cmpVal4(f1, 2.0f); - f2 = ++f1; - cmpVal4(f1, 3.0f); - cmpVal4(f2, 3.0f); - f2 = --f1; - cmpVal4(f1, 2.0f); - cmpVal4(f1, 2.0f); - - f1.x = 3.0f; - f1.y = 3.0f; - f1.z = 3.0f; - f1.w = 3.0f; - f2.x = 4.0f; - f2.y = 4.0f; - f2.z = 4.0f; - f2.w = 4.0f; - f3.x = 3.0f; - f3.y = 3.0f; - f3.z = 3.0f; - f3.w = 3.0f; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - return true; -} - -__device__ bool TestULongLong1() { - ulonglong1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - - -__device__ bool TestULongLong2() { - ulonglong2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestULongLong3() { - ulonglong3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestULongLong4() { - ulonglong4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - - -__global__ void CheckVectorTypes(hipLaunchParm lp, bool* ptr) { - if (TestFloat1() && TestFloat2() && TestFloat3() && TestFloat4() && TestUChar1() && - TestUChar2() && TestUChar3() && TestUChar4() && TestChar1() && TestChar2() && TestChar3() && - TestChar4() && TestUShort1() && TestUShort2() && TestUShort3() && TestUShort4() && - TestShort1() && TestShort2() && TestShort3() && TestShort4() && TestUInt1() && - TestUInt2() && TestUInt3() && TestUInt4() && TestInt1() && TestInt2() && TestInt3() && - TestInt4() && TestULong1() && TestULong2() && TestULong3() && TestULong4() && TestLong1() && - TestLong2() && TestLong3() && TestLong4() && TestULongLong1() && TestULongLong2() && - TestULongLong3() && TestULongLong4() == true) { - ptr[0] = true; - } +__global__ +void CheckVectorTypes(bool* ptr) { + ptr[0] = TestVectorTypes< + char1, char2, char3, char4, + uchar1, uchar2, uchar3, uchar4, + short1, short2, short3, short4, + ushort1, ushort2, ushort3, ushort4, + int1, int2, int3, int4, + uint1, uint2, uint3, uint4, + long1, long2, long3, long4, + ulong1, ulong2, ulong3, ulong4, + longlong1, longlong2, longlong3, longlong4, + ulonglong1, ulonglong2, ulonglong3, ulonglong4, + float1, float2, float3, float4, + double1, double2, double3, double4>(); } int main() { - assert(sizeof(float1) == 4); - assert(sizeof(float2) == 8); - assert(sizeof(float3) == 12); - assert(sizeof(float4) == 16); + static_assert(sizeof(float1) == 4, ""); + static_assert(sizeof(float2) >= 8, ""); + static_assert(sizeof(float3) >= 12, ""); + static_assert(sizeof(float4) >= 16, ""); bool* ptr = nullptr; if (hipMalloc(&ptr, sizeof(bool)) != HIP_SUCCESS) return EXIT_FAILURE; - std::unique_ptr correct{ptr, hipFree}; - hipLaunchKernel(CheckVectorTypes, dim3(1, 1, 1), dim3(1, 1, 1), 0, 0, correct.get()); - bool passed = false; + unique_ptr correct{ptr, hipFree}; + hipLaunchKernelGGL( + CheckVectorTypes, dim3(1, 1, 1), dim3(1, 1, 1), 0, 0, correct.get()); + bool passed = true; if (hipMemcpyDtoH(&passed, correct.get(), sizeof(bool)) != HIP_SUCCESS) { return EXIT_FAILURE; } if (passed == true) { - std::cout << "PASSED" << std::endl; - return 0; - } else - return EXIT_FAILURE; -} + passed(); + } + else { + failed("Failed some vector test."); + } +} \ No newline at end of file diff --git a/projects/hip/tests/src/deviceLib/hip_test_ldg.cpp b/projects/hip/tests/src/deviceLib/hip_test_ldg.cpp index 4dea81d9b9..7274baa92c 100644 --- a/projects/hip/tests/src/deviceLib/hip_test_ldg.cpp +++ b/projects/hip/tests/src/deviceLib/hip_test_ldg.cpp @@ -35,7 +35,7 @@ THE SOFTWARE. #include "hip/hip_vector_types.h" #include "test_common.h" -#if (__hcc_workweek__ >= 16164) || defined(__HIP_PLATFORM_NVCC__) +#if (__hcc_workweek__ >= 16164) || defined(__HIP_PLATFORM_NVCC__) || defined(__HIP_CLANG_ONLY__) #define HIP_ASSERT(x) (assert((x) == hipSuccess)) diff --git a/projects/hip/tests/src/deviceLib/vector_test_common.h b/projects/hip/tests/src/deviceLib/vector_test_common.h new file mode 100644 index 0000000000..fac5ab84a1 --- /dev/null +++ b/projects/hip/tests/src/deviceLib/vector_test_common.h @@ -0,0 +1,69 @@ +/* +Copyright (c) 2015-2017 Advanced Micro Devices, Inc. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ +#pragma once + +#include + +template +using Enable_if_t = typename std::enable_if::type; + +__host__ __device__ +std::false_type is_vec4(...); +__host__ __device__ +std::false_type is_vec3(...); +__host__ __device__ +std::false_type is_vec2(...); +__host__ __device__ +std::false_type is_vec1(...); + +template +__host__ __device__ +auto is_vec4(const T&) -> decltype(std::declval().xyzw, std::true_type{}); +template< + typename T, Enable_if_t())){}>* = nullptr> +__host__ __device__ +auto is_vec3(const T&) -> decltype(std::declval().xyz, std::true_type{}); +template< + typename T, + Enable_if_t< + !decltype(is_vec4(std::declval())){} && + !decltype(is_vec3(std::declval())){}>* = nullptr> +__host__ __device__ +auto is_vec2(const T&) -> decltype(std::declval().xy, std::true_type{}); +template< + typename T, + Enable_if_t< + !decltype(is_vec4(std::declval())){} && + !decltype(is_vec3(std::declval())){} && + !decltype(is_vec2(std::declval())){}>* = nullptr> +__host__ __device__ +auto is_vec1(const T&) -> decltype(std::declval().x, std::true_type{}); + +template +__host__ __device__ +constexpr +bool is_vec() { + return (dimension == 1) ? decltype(is_vec1(std::declval())){} : + ((dimension == 2) ? decltype(is_vec2(std::declval())){} : + ((dimension == 3) ? decltype(is_vec3(std::declval())){} : + decltype(is_vec4(std::declval())){})); +} \ No newline at end of file