From f5508db24f4b81619af6ca19fc81dde7c75943a2 Mon Sep 17 00:00:00 2001 From: Vsevolod Livinskij Date: Mon, 17 Feb 2014 18:55:40 +0400 Subject: [PATCH 1/3] Saturation arithmetic (sub and add) was added for int32/int64. --- stdlib.ispc | 128 +++++++++++++++++++++++++++++++++++++++++ tests/padds_i32.ispc | 27 +++++++++ tests/padds_i64.ispc | 27 +++++++++ tests/padds_vi32.ispc | 27 +++++++++ tests/padds_vi64.ispc | 27 +++++++++ tests/paddus_i32.ispc | 21 +++++++ tests/paddus_i64.ispc | 21 +++++++ tests/paddus_vi32.ispc | 21 +++++++ tests/paddus_vi64.ispc | 21 +++++++ tests/psubs_i32.ispc | 27 +++++++++ tests/psubs_i64.ispc | 27 +++++++++ tests/psubs_vi32.ispc | 27 +++++++++ tests/psubs_vi64.ispc | 27 +++++++++ tests/psubus_i32.ispc | 21 +++++++ tests/psubus_i64.ispc | 21 +++++++ tests/psubus_vi32.ispc | 21 +++++++ tests/psubus_vi64.ispc | 21 +++++++ 17 files changed, 512 insertions(+) create mode 100644 tests/padds_i32.ispc create mode 100644 tests/padds_i64.ispc create mode 100644 tests/padds_vi32.ispc create mode 100644 tests/padds_vi64.ispc create mode 100644 tests/paddus_i32.ispc create mode 100644 tests/paddus_i64.ispc create mode 100644 tests/paddus_vi32.ispc create mode 100644 tests/paddus_vi64.ispc create mode 100644 tests/psubs_i32.ispc create mode 100644 tests/psubs_i64.ispc create mode 100644 tests/psubs_vi32.ispc create mode 100644 tests/psubs_vi64.ispc create mode 100644 tests/psubus_i32.ispc create mode 100644 tests/psubus_i64.ispc create mode 100644 tests/psubus_vi32.ispc create mode 100644 tests/psubus_vi64.ispc diff --git a/stdlib.ispc b/stdlib.ispc index cb41c49c..160c520d 100644 --- a/stdlib.ispc +++ b/stdlib.ispc @@ -4411,6 +4411,42 @@ static inline varying int16 saturating_add(varying int16 a, varying int16 b) { return __padds_vi16(a, b); } +static inline uniform int32 saturating_add(uniform int32 a, uniform int32 b) { + uniform unsigned int32 a_unsig = a, b_unsig = b; + uniform unsigned int32 result = a_unsig + b_unsig; + a_unsig = (a_unsig >> 31) + INT32_MAX; + if ((uniform int32) ((a_unsig ^ b_unsig) | ~(b_unsig ^ result)) >= 0) + result = a_unsig; + return result; +} + +static inline varying int32 saturating_add(varying int32 a, varying int32 b) { + varying unsigned int32 a_unsig = a, b_unsig = b; + varying unsigned int32 result = a_unsig + b_unsig; + a_unsig = (a_unsig >> 31) + INT32_MAX; + if ((varying int32) ((a_unsig ^ b_unsig) | ~(b_unsig ^ result)) >= 0) + result = a_unsig; + return result; +} + +static inline uniform int64 saturating_add(uniform int64 a, uniform int64 b) { + uniform unsigned int64 a_unsig = a, b_unsig = b; + uniform unsigned int64 result = a_unsig + b_unsig; + a_unsig = (a_unsig >> 63) + INT64_MAX; + if ((uniform int64) ((a_unsig ^ b_unsig) | ~(b_unsig ^ result)) >= 0) + result = a_unsig; + return result; +} + +static inline varying int64 saturating_add(varying int64 a, varying int64 b) { + varying unsigned int64 a_unsig = a, b_unsig = b; + varying unsigned int64 result = a_unsig + b_unsig; + a_unsig = (a_unsig >> 63) + INT64_MAX; + if ((varying int64) ((a_unsig ^ b_unsig) | ~(b_unsig ^ result)) >= 0) + result = a_unsig; + return result; +} + static inline uniform unsigned int8 saturating_add(uniform unsigned int8 a, uniform unsigned int8 b) { uniform unsigned int8 result = a + b; @@ -4435,6 +4471,34 @@ static inline varying unsigned int16 saturating_add(varying unsigned int16 a, return __paddus_vi16(a, b); } +static inline uniform unsigned int32 saturating_add(uniform unsigned int32 a, + uniform unsigned int32 b) { + uniform unsigned int32 result = a + b; + result |= (-(uniform int32)(result < a)); + return result; +} + +static inline varying unsigned int32 saturating_add(varying unsigned int32 a, + varying unsigned int32 b) { + varying unsigned int32 result = a + b; + result |= (-(varying int32)(result < a)); + return result; +} + +static inline uniform unsigned int64 saturating_add(uniform unsigned int64 a, + uniform unsigned int64 b) { + uniform unsigned int64 result = a + b; + result |= (-(uniform int64)(result < a)); + return result; +} + +static inline varying unsigned int64 saturating_add(varying unsigned int64 a, + varying unsigned int64 b) { + varying unsigned int64 result = a + b; + result |= (-(varying int64)(result < a)); + return result; +} + static inline uniform int8 saturating_sub(uniform int8 a, uniform int8 b) { uniform unsigned int8 a_unsig = a, b_unsig = b; uniform unsigned int8 result = a_unsig - b_unsig; @@ -4461,6 +4525,42 @@ static inline varying int16 saturating_sub(varying int16 a, varying int16 b) { return __psubs_vi16(a, b); } +static inline uniform int32 saturating_sub(uniform int32 a, uniform int32 b) { + uniform unsigned int32 a_unsig = a, b_unsig = b; + uniform unsigned int32 result = a_unsig - b_unsig; + a_unsig = (a_unsig >> 31) + INT32_MAX; + if ((uniform int32) ((a_unsig ^ b_unsig) & (a_unsig ^ result)) < 0) + result = a_unsig; + return result; +} + +static inline varying int32 saturating_sub(varying int32 a, varying int32 b) { + varying unsigned int32 a_unsig = a, b_unsig = b; + varying unsigned int32 result = a_unsig - b_unsig; + a_unsig = (a_unsig >> 31) + INT32_MAX; + if ((varying int32) ((a_unsig ^ b_unsig) & (a_unsig ^ result)) < 0) + result = a_unsig; + return result; +} + +static inline uniform int64 saturating_sub(uniform int64 a, uniform int64 b) { + uniform unsigned int64 a_unsig = a, b_unsig = b; + uniform unsigned int64 result = a_unsig - b_unsig; + a_unsig = (a_unsig >> 63) + INT64_MAX; + if ((uniform int64) ((a_unsig ^ b_unsig) & (a_unsig ^ result)) < 0) + result = a_unsig; + return result; +} + +static inline varying int64 saturating_sub(varying int64 a, varying int64 b) { + varying unsigned int64 a_unsig = a, b_unsig = b; + varying unsigned int64 result = a_unsig - b_unsig; + a_unsig = (a_unsig >> 63) + INT64_MAX; + if ((varying int64) ((a_unsig ^ b_unsig) & (a_unsig ^ result)) < 0) + result = a_unsig; + return result; +} + static inline uniform unsigned int8 saturating_sub(uniform unsigned int8 a, uniform unsigned int8 b) { uniform unsigned int8 result = a - b; @@ -4484,6 +4584,34 @@ static inline varying unsigned int16 saturating_sub(varying unsigned int16 a, varying unsigned int16 b) { return __psubus_vi16(a, b); } + +static inline uniform unsigned int32 saturating_sub(uniform unsigned int32 a, + uniform unsigned int32 b) { + uniform unsigned int32 result = a - b; + result &= (-(uniform int32)(result <= a)); + return result; +} + +static inline varying unsigned int32 saturating_sub(varying unsigned int32 a, + varying unsigned int32 b) { + varying unsigned int32 result = a - b; + result &= (-(varying int32)(result <= a)); + return result; +} + +static inline uniform unsigned int64 saturating_sub(uniform unsigned int64 a, + uniform unsigned int64 b) { + uniform unsigned int64 result = a - b; + result &= (-(uniform int64)(result <= a)); + return result; +} + +static inline varying unsigned int64 saturating_sub(varying unsigned int64 a, + varying unsigned int64 b) { + varying unsigned int64 result = a - b; + result &= (-(varying int64)(result <= a)); + return result; +} /////////////////////////////////////////////////////////////////////////// // rdrand diff --git a/tests/padds_i32.ispc b/tests/padds_i32.ispc new file mode 100644 index 00000000..a92e640f --- /dev/null +++ b/tests/padds_i32.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_add(a_max, b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_add(a_min, -b); + } + else { + RET[programIndex] = saturating_add(a_min, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (uniform int32) 2147483647; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (uniform int32) -2147483648; + } + else { + RET[programIndex] = (uniform int32) -2147483643; + } +} diff --git a/tests/padds_i64.ispc b/tests/padds_i64.ispc new file mode 100644 index 00000000..be21dc88 --- /dev/null +++ b/tests/padds_i64.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min signed int64 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_add(a_max, b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_add(a_min, -b); + } + else { + RET[programIndex] = saturating_add(a_min, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (uniform int64) 9223372036854775807; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (uniform int64) -9223372036854775808; + } + else { + RET[programIndex] = (uniform int64) -9223372036854775803; + } +} diff --git a/tests/padds_vi32.ispc b/tests/padds_vi32.ispc new file mode 100644 index 00000000..f566f84b --- /dev/null +++ b/tests/padds_vi32.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_add(a_max, b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_add(a_min, -b); + } + else { + RET[programIndex] = saturating_add(a_min, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (varying int32) 2147483647; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (varying int32) -2147483648; + } + else { + RET[programIndex] = (varying int32) -2147483643; + } +} diff --git a/tests/padds_vi64.ispc b/tests/padds_vi64.ispc new file mode 100644 index 00000000..c8492fb4 --- /dev/null +++ b/tests/padds_vi64.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min signed int64 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_add(a_max, b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_add(a_min, -b); + } + else { + RET[programIndex] = saturating_add(a_min, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (varying int64) 9223372036854775807; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (varying int64) -9223372036854775808; + } + else { + RET[programIndex] = (varying int64) -9223372036854775803; + } +} diff --git a/tests/paddus_i32.ispc b/tests/paddus_i32.ispc new file mode 100644 index 00000000..2745b5eb --- /dev/null +++ b/tests/paddus_i32.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_add(a_max, b); + } + else { + RET[programIndex] = saturating_add(a_min, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (uniform unsigned int32) 4294967295; + } + else { + RET[programIndex] = (uniform unsigned int32) 5; + } +} diff --git a/tests/paddus_i64.ispc b/tests/paddus_i64.ispc new file mode 100644 index 00000000..ff63307d --- /dev/null +++ b/tests/paddus_i64.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_add(a_max, b); + } + else { + RET[programIndex] = saturating_add(a_min, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (uniform unsigned int64) 18446744073709551615; + } + else { + RET[programIndex] = (uniform unsigned int64) 5; + } +} diff --git a/tests/paddus_vi32.ispc b/tests/paddus_vi32.ispc new file mode 100644 index 00000000..eaa4097f --- /dev/null +++ b/tests/paddus_vi32.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_add(a_max, b); + } + else { + RET[programIndex] = saturating_add(a_min, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (varying unsigned int32) 4294967295; + } + else { + RET[programIndex] = (varying unsigned int32) 5; + } +} diff --git a/tests/paddus_vi64.ispc b/tests/paddus_vi64.ispc new file mode 100644 index 00000000..3694125e --- /dev/null +++ b/tests/paddus_vi64.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_add(a_max, b); + } + else { + RET[programIndex] = saturating_add(a_min, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (varying unsigned int64) 18446744073709551615; + } + else { + RET[programIndex] = (varying unsigned int64) 5; + } +} diff --git a/tests/psubs_i32.ispc b/tests/psubs_i32.ispc new file mode 100644 index 00000000..9fefd861 --- /dev/null +++ b/tests/psubs_i32.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform int32 a_max = 2147483647, a_min = -2147483648; // max and min int32 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_sub(a_min, b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_sub(a_max, -b); + } + else { + RET[programIndex] = saturating_sub(a_max, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (uniform int32) -2147483648; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (uniform int32) 2147483647; + } + else { + RET[programIndex] = (uniform int32) 2147483642; + } +} diff --git a/tests/psubs_i64.ispc b/tests/psubs_i64.ispc new file mode 100644 index 00000000..b1e061bc --- /dev/null +++ b/tests/psubs_i64.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min int64 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_sub(a_min, b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_sub(a_max, -b); + } + else { + RET[programIndex] = saturating_sub(a_max, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (uniform int64) -9223372036854775808; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (uniform int64) 9223372036854775807; + } + else { + RET[programIndex] = (uniform int64) 9223372036854775802; + } +} diff --git a/tests/psubs_vi32.ispc b/tests/psubs_vi32.ispc new file mode 100644 index 00000000..1dd2720c --- /dev/null +++ b/tests/psubs_vi32.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying int32 a_max = 2147483647, a_min = -2147483648; // max and min int32 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_sub(a_min, b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_sub(a_max, -b); + } + else { + RET[programIndex] = saturating_sub(a_max, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (varying int32) -2147483648; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (varying int32) 2147483647; + } + else { + RET[programIndex] = (varying int32) 2147483642; + } +} diff --git a/tests/psubs_vi64.ispc b/tests/psubs_vi64.ispc new file mode 100644 index 00000000..75a9711e --- /dev/null +++ b/tests/psubs_vi64.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min int64 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_sub(a_min, b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_sub(a_max, -b); + } + else { + RET[programIndex] = saturating_sub(a_max, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (varying int64) -9223372036854775808; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (varying int64) 9223372036854775807; + } + else { + RET[programIndex] = (varying int64) 9223372036854775802; + } +} diff --git a/tests/psubus_i32.ispc b/tests/psubus_i32.ispc new file mode 100644 index 00000000..dc188fc3 --- /dev/null +++ b/tests/psubus_i32.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_sub(a_min, b); + } + else { + RET[programIndex] = saturating_sub(a_max, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (uniform unsigned int32) 0; + } + else { + RET[programIndex] = (uniform unsigned int32) 4294967290; + } +} diff --git a/tests/psubus_i64.ispc b/tests/psubus_i64.ispc new file mode 100644 index 00000000..bca59a40 --- /dev/null +++ b/tests/psubus_i64.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_sub(a_min, b); + } + else { + RET[programIndex] = saturating_sub(a_max, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (uniform unsigned int64) 0; + } + else { + RET[programIndex] = (uniform unsigned int64) 18446744073709551610; + } +} diff --git a/tests/psubus_vi32.ispc b/tests/psubus_vi32.ispc new file mode 100644 index 00000000..dffcaeb4 --- /dev/null +++ b/tests/psubus_vi32.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_sub(a_min, b); + } + else { + RET[programIndex] = saturating_sub(a_max, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (varying unsigned int32) 0; + } + else { + RET[programIndex] = (varying unsigned int32) 4294967290; + } +} diff --git a/tests/psubus_vi64.ispc b/tests/psubus_vi64.ispc new file mode 100644 index 00000000..e56d8972 --- /dev/null +++ b/tests/psubus_vi64.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_sub(a_min, b); + } + else { + RET[programIndex] = saturating_sub(a_max, b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (varying unsigned int64) 0; + } + else { + RET[programIndex] = (varying unsigned int64) 18446744073709551610; + } +} From 735e6a8ab356e7b678402188c7582c15e392cefa Mon Sep 17 00:00:00 2001 From: Vsevolod Livinskij Date: Tue, 18 Feb 2014 02:07:13 +0400 Subject: [PATCH 2/3] Saturation arithmetic mul and div for int8/int16/int32 and div for int64 was added --- stdlib.ispc | 210 +++++++++++++++++++++++++++++++++++++++++ tests/pdivs_i16.ispc | 27 ++++++ tests/pdivs_i32.ispc | 27 ++++++ tests/pdivs_i64.ispc | 27 ++++++ tests/pdivs_i8.ispc | 27 ++++++ tests/pdivs_vi16.ispc | 27 ++++++ tests/pdivs_vi32.ispc | 27 ++++++ tests/pdivs_vi64.ispc | 27 ++++++ tests/pdivs_vi8.ispc | 27 ++++++ tests/pdivus_i16.ispc | 21 +++++ tests/pdivus_i32.ispc | 21 +++++ tests/pdivus_i64.ispc | 21 +++++ tests/pdivus_i8.ispc | 21 +++++ tests/pdivus_vi16.ispc | 21 +++++ tests/pdivus_vi32.ispc | 21 +++++ tests/pdivus_vi64.ispc | 21 +++++ tests/pdivus_vi8.ispc | 21 +++++ tests/pmuls_i16.ispc | 28 ++++++ tests/pmuls_i32.ispc | 28 ++++++ tests/pmuls_i8.ispc | 29 ++++++ tests/pmuls_vi16.ispc | 28 ++++++ tests/pmuls_vi32.ispc | 28 ++++++ tests/pmuls_vi8.ispc | 28 ++++++ tests/pmulus_i16.ispc | 28 ++++++ tests/pmulus_i32.ispc | 28 ++++++ tests/pmulus_i8.ispc | 28 ++++++ tests/pmulus_vi16.ispc | 28 ++++++ tests/pmulus_vi32.ispc | 28 ++++++ tests/pmulus_vi8.ispc | 28 ++++++ 29 files changed, 931 insertions(+) create mode 100644 tests/pdivs_i16.ispc create mode 100644 tests/pdivs_i32.ispc create mode 100644 tests/pdivs_i64.ispc create mode 100644 tests/pdivs_i8.ispc create mode 100644 tests/pdivs_vi16.ispc create mode 100644 tests/pdivs_vi32.ispc create mode 100644 tests/pdivs_vi64.ispc create mode 100644 tests/pdivs_vi8.ispc create mode 100644 tests/pdivus_i16.ispc create mode 100644 tests/pdivus_i32.ispc create mode 100644 tests/pdivus_i64.ispc create mode 100644 tests/pdivus_i8.ispc create mode 100644 tests/pdivus_vi16.ispc create mode 100644 tests/pdivus_vi32.ispc create mode 100644 tests/pdivus_vi64.ispc create mode 100644 tests/pdivus_vi8.ispc create mode 100644 tests/pmuls_i16.ispc create mode 100644 tests/pmuls_i32.ispc create mode 100644 tests/pmuls_i8.ispc create mode 100644 tests/pmuls_vi16.ispc create mode 100644 tests/pmuls_vi32.ispc create mode 100644 tests/pmuls_vi8.ispc create mode 100644 tests/pmulus_i16.ispc create mode 100644 tests/pmulus_i32.ispc create mode 100644 tests/pmulus_i8.ispc create mode 100644 tests/pmulus_vi16.ispc create mode 100644 tests/pmulus_vi32.ispc create mode 100644 tests/pmulus_vi8.ispc diff --git a/stdlib.ispc b/stdlib.ispc index 160c520d..f76ed15c 100644 --- a/stdlib.ispc +++ b/stdlib.ispc @@ -4612,6 +4612,216 @@ static inline varying unsigned int64 saturating_sub(varying unsigned int64 a, result &= (-(varying int64)(result <= a)); return result; } + +static inline uniform int8 saturating_div(uniform int8 a, uniform int8 b) { + /* Only one way to overflow, so test for and prevent it. */ + a += !((b + 1) | ((uniform unsigned int8) a + INT8_MIN)); + return a / b; +} + +static inline varying int8 saturating_div(varying int8 a, varying int8 b) { + /* Only one way to overflow, so test for and prevent it. */ + a += !((b + 1) | ((varying unsigned int8) a + INT8_MIN)); + return a / b; +} + +static inline uniform int16 saturating_div(uniform int16 a, uniform int16 b) { + /* Only one way to overflow, so test for and prevent it. */ + a += !((b + 1) | ((uniform unsigned int16) a + INT16_MIN)); + return a / b; +} + +static inline varying int16 saturating_div(varying int16 a, varying int16 b) { + /* Only one way to overflow, so test for and prevent it. */ + a += !((b + 1) | ((varying unsigned int16) a + INT16_MIN)); + return a / b; +} + +static inline uniform int32 saturating_div(uniform int32 a, uniform int32 b) { + /* Only one way to overflow, so test for and prevent it. */ + a += !((b + 1) | ((uniform unsigned int32) a + INT32_MIN)); + return a / b; +} + +static inline varying int32 saturating_div(varying int32 a, varying int32 b) { + /* Only one way to overflow, so test for and prevent it. */ + a += !((b + 1) | ((varying unsigned int32) a + INT32_MIN)); + return a / b; +} + +static inline uniform int64 saturating_div(uniform int64 a, uniform int64 b) { + /* Only one way to overflow, so test for and prevent it. */ + a += !((b + 1) | ((uniform unsigned int64) a + INT64_MIN)); + return a / b; +} + +static inline varying int64 saturating_div(varying int64 a, varying int64 b) { + /* Only one way to overflow, so test for and prevent it. */ + a += !((b + 1) | ((varying unsigned int64) a + INT64_MIN)); + return a / b; +} + +static inline uniform unsigned int8 saturating_div(uniform unsigned int8 a, + uniform unsigned int8 b) { + /* No overflow possible */ + return a / b; +} + +static inline varying unsigned int8 saturating_div(varying unsigned int8 a, + varying unsigned int8 b) { + /* No overflow possible */ + return a / b; +} + +static inline uniform unsigned int16 saturating_div(uniform unsigned int16 a, + uniform unsigned int16 b) { + /* No overflow possible */ + return a / b; +} + +static inline varying unsigned int16 saturating_div(varying unsigned int16 a, + varying unsigned int16 b) { + /* No overflow possible */ + return a / b; +} + +static inline uniform unsigned int32 saturating_div(uniform unsigned int32 a, + uniform unsigned int32 b) { + /* No overflow possible */ + return a / b; +} + +static inline varying unsigned int32 saturating_div(varying unsigned int32 a, + varying unsigned int32 b) { + /* No overflow possible */ + return a / b; +} + +static inline uniform unsigned int64 saturating_div(uniform unsigned int64 a, + uniform unsigned int64 b) { + /* No overflow possible */ + return a / b; +} + +static inline varying unsigned int64 saturating_div(varying unsigned int64 a, + varying unsigned int64 b) { + /* No overflow possible */ + return a / b; +} + +static inline uniform int8 saturating_mul(uniform int8 a, uniform int8 b) { + uniform int16 result = (uniform int16) a * (uniform int16) b; + uniform unsigned int8 result2 = ((uniform unsigned int8) (a ^ b) >> 7) + INT8_MAX; + uniform int8 hi = result >> 8; + uniform int8 lo = result; + if (hi != (lo >> 7)) + result = result2; + return result; +} + +static inline varying int8 saturating_mul(varying int8 a, varying int8 b) { + varying int16 result = (varying int16) a * (varying int16) b; + varying unsigned int8 result2 = ((varying unsigned int8) (a ^ b) >> 7) + INT8_MAX; + varying int8 hi = result >> 8; + varying int8 lo = result; + if (hi != (lo >> 7)) + result = result2; + return result; +} + +static inline uniform int16 saturating_mul(uniform int16 a, uniform int16 b) { + uniform int32 result = (uniform int32) a * (uniform int32) b; + uniform unsigned int16 result2 = ((uniform unsigned int16) (a ^ b) >> 15) + INT16_MAX; + uniform int16 hi = result >> 16; + uniform int16 lo = result; + if (hi != (lo >> 15)) + result = result2; + return result; +} + +static inline varying int16 saturating_mul(varying int16 a, varying int16 b) { + varying int32 result = (varying int32) a * (varying int32) b; + varying unsigned int16 result2 = ((varying unsigned int16) (a ^ b) >> 15) + INT16_MAX; + varying int16 hi = result >> 16; + varying int16 lo = result; + if (hi != (lo >> 15)) + result = result2; + return result; +} + +static inline uniform int32 saturating_mul(uniform int32 a, uniform int32 b) { + uniform int64 result = (uniform int64) a * (uniform int64) b; + uniform unsigned int32 result2 = ((uniform unsigned int32) (a ^ b) >> 31) + INT32_MAX; + uniform int32 hi = result >> 32; + uniform int32 lo = result; + if (hi != (lo >> 31)) + result = result2; + return result; +} + +static inline varying int32 saturating_mul(varying int32 a, varying int32 b) { + varying int64 result = (varying int64) a * (varying int64) b; + varying unsigned int32 result2 = ((varying unsigned int32) (a ^ b) >> 31) + INT32_MAX; + varying int32 hi = result >> 32; + varying int32 lo = result; + if (hi != (lo >> 31)) + result = result2; + return result; +} + +static inline uniform unsigned int8 saturating_mul(uniform unsigned int8 a, + uniform unsigned int8 b) { + uniform unsigned int16 result = (uniform unsigned int16) a * + (uniform unsigned int16) b; + uniform unsigned int8 hi = result >> 8; + uniform unsigned int8 lo = result; + return lo | - (uniform int8) !! hi; +} + +static inline varying unsigned int8 saturating_mul(varying unsigned int8 a, + varying unsigned int8 b) { + varying unsigned int16 result = (varying unsigned int16) a * + (varying unsigned int16) b; + varying unsigned int8 hi = result >> 8; + varying unsigned int8 lo = result; + return lo | - (varying int8) !! hi; +} + +static inline uniform unsigned int16 saturating_mul(uniform unsigned int16 a, + uniform unsigned int16 b) { + uniform unsigned int32 result = (uniform unsigned int32) a * + (uniform unsigned int32) b; + uniform unsigned int16 hi = result >> 16; + uniform unsigned int16 lo = result; + return lo | - (uniform int16) !! hi; +} + +static inline varying unsigned int16 saturating_mul(varying unsigned int16 a, + varying unsigned int16 b) { + varying unsigned int32 result = (varying unsigned int32) a * + (varying unsigned int32) b; + varying unsigned int16 hi = result >> 16; + varying unsigned int16 lo = result; + return lo | - (varying int16) !! hi; +} + +static inline uniform unsigned int32 saturating_mul(uniform unsigned int32 a, + uniform unsigned int32 b) { + uniform unsigned int64 result = (uniform unsigned int64) a * + (uniform unsigned int64) b; + uniform unsigned int32 hi = result >> 32; + uniform unsigned int32 lo = result; + return lo | - (uniform int32) !! hi; +} + +static inline varying unsigned int32 saturating_mul(varying unsigned int32 a, + varying unsigned int32 b) { + varying unsigned int64 result = (varying unsigned int64) a * + (varying unsigned int64) b; + varying unsigned int32 hi = result >> 32; + varying unsigned int32 lo = result; + return lo | - (varying int32) !! hi; +} /////////////////////////////////////////////////////////////////////////// // rdrand diff --git a/tests/pdivs_i16.ispc b/tests/pdivs_i16.ispc new file mode 100644 index 00000000..b9b5858f --- /dev/null +++ b/tests/pdivs_i16.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform int16 a_max = 32767, a_min = -32768; // max and min signed int16 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_div(a_max, (uniform int16) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_div(a_min, (uniform int16) b); + } + else { + RET[programIndex] = saturating_div(a_min, (uniform int16) -1); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (uniform int16) 6553.4; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (uniform int16) -6553.6; + } + else { + RET[programIndex] = (uniform int16) 32767; + } +} diff --git a/tests/pdivs_i32.ispc b/tests/pdivs_i32.ispc new file mode 100644 index 00000000..99760828 --- /dev/null +++ b/tests/pdivs_i32.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_div(a_max, (uniform int32) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_div(a_min, (uniform int32) b); + } + else { + RET[programIndex] = saturating_div(a_min, (uniform int32) -1); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (uniform int32) 429496729.4; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (uniform int32) -429496729.6; + } + else { + RET[programIndex] = (uniform int32) 2147483647; + } +} diff --git a/tests/pdivs_i64.ispc b/tests/pdivs_i64.ispc new file mode 100644 index 00000000..e0de47f7 --- /dev/null +++ b/tests/pdivs_i64.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min signed int64 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_div(a_max, (uniform int64) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_div(a_min, (uniform int64) b); + } + else { + RET[programIndex] = saturating_div(a_min, (uniform int64) -1); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (uniform int64) 1844674407370955161.4; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (uniform int64) -1844674407370955161.6; + } + else { + RET[programIndex] = (uniform int64) 9223372036854775807; + } +} diff --git a/tests/pdivs_i8.ispc b/tests/pdivs_i8.ispc new file mode 100644 index 00000000..c68dcd64 --- /dev/null +++ b/tests/pdivs_i8.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform int8 a_max = 127, a_min = -128; // max and min signed int8 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_div(a_max, (uniform int8) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_div(a_min, (uniform int8) b); + } + else { + RET[programIndex] = saturating_div(a_min, (uniform int8) -1); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (uniform int8) 25.4; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (uniform int8) -25.6; + } + else { + RET[programIndex] = (uniform int8) 127; + } +} diff --git a/tests/pdivs_vi16.ispc b/tests/pdivs_vi16.ispc new file mode 100644 index 00000000..0b119672 --- /dev/null +++ b/tests/pdivs_vi16.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying int16 a_max = 32767, a_min = -32768; // max and min signed int16 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_div(a_max, (varying int16) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_div(a_min, (varying int16) b); + } + else { + RET[programIndex] = saturating_div(a_min, (varying int16) -1); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (varying int16) 6553.4; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (varying int16) -6553.6; + } + else { + RET[programIndex] = (varying int16) 32767; + } +} diff --git a/tests/pdivs_vi32.ispc b/tests/pdivs_vi32.ispc new file mode 100644 index 00000000..4f6b0bae --- /dev/null +++ b/tests/pdivs_vi32.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_div(a_max, (varying int32) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_div(a_min, (varying int32) b); + } + else { + RET[programIndex] = saturating_div(a_min, (varying int32) -1); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (varying int32) 429496729.4; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (varying int32) -429496729.6; + } + else { + RET[programIndex] = (varying int32) 2147483647; + } +} diff --git a/tests/pdivs_vi64.ispc b/tests/pdivs_vi64.ispc new file mode 100644 index 00000000..cb4fba70 --- /dev/null +++ b/tests/pdivs_vi64.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min signed int64 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_div(a_max, (varying int64) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_div(a_min, (varying int64) b); + } + else { + RET[programIndex] = saturating_div(a_min, (varying int64) -1); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (varying int64) 1844674407370955161.4; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (varying int64) -1844674407370955161.6; + } + else { + RET[programIndex] = (varying int64) 9223372036854775807; + } +} diff --git a/tests/pdivs_vi8.ispc b/tests/pdivs_vi8.ispc new file mode 100644 index 00000000..7b021645 --- /dev/null +++ b/tests/pdivs_vi8.ispc @@ -0,0 +1,27 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying int8 a_max = 127, a_min = -128; // max and min signed int8 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_div(a_max, (varying int8) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_div(a_min, (varying int8) b); + } + else { + RET[programIndex] = saturating_div(a_min, (varying int8) -1); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (varying int8) 25.4; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (varying int8) -25.6; + } + else { + RET[programIndex] = (varying int8) 127; + } +} diff --git a/tests/pdivus_i16.ispc b/tests/pdivus_i16.ispc new file mode 100644 index 00000000..827eedfc --- /dev/null +++ b/tests/pdivus_i16.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform unsigned int16 a_max = 65535, a_min = 0; // max and min unsigned int16 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_div(a_min, (uniform unsigned int16) b); + } + else { + RET[programIndex] = saturating_div(a_max, (uniform unsigned int16) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (uniform unsigned int16) 0; + } + else { + RET[programIndex] = (uniform unsigned int16) 13107; + } +} diff --git a/tests/pdivus_i32.ispc b/tests/pdivus_i32.ispc new file mode 100644 index 00000000..ec4c97be --- /dev/null +++ b/tests/pdivus_i32.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_div(a_min, (uniform unsigned int32) b); + } + else { + RET[programIndex] = saturating_div(a_max, (uniform unsigned int32) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (uniform unsigned int32) 0; + } + else { + RET[programIndex] = (uniform unsigned int32) 858993459; + } +} diff --git a/tests/pdivus_i64.ispc b/tests/pdivus_i64.ispc new file mode 100644 index 00000000..ddc4d866 --- /dev/null +++ b/tests/pdivus_i64.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_div(a_min, (uniform unsigned int64) b); + } + else { + RET[programIndex] = saturating_div(a_max, (uniform unsigned int64) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (uniform unsigned int64) 0; + } + else { + RET[programIndex] = (uniform unsigned int64) 3689348814741910323; + } +} diff --git a/tests/pdivus_i8.ispc b/tests/pdivus_i8.ispc new file mode 100644 index 00000000..0c133a1d --- /dev/null +++ b/tests/pdivus_i8.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform unsigned int8 a_max = 255, a_min = 0; // max and min unsigned int8 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_div(a_min, (uniform unsigned int8) b); + } + else { + RET[programIndex] = saturating_div(a_max, (uniform unsigned int8) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (uniform unsigned int8) 0; + } + else { + RET[programIndex] = (uniform unsigned int8) 51; + } +} diff --git a/tests/pdivus_vi16.ispc b/tests/pdivus_vi16.ispc new file mode 100644 index 00000000..754399db --- /dev/null +++ b/tests/pdivus_vi16.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying unsigned int16 a_max = 65535, a_min = 0; // max and min unsigned int16 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_div(a_min, (varying unsigned int16) b); + } + else { + RET[programIndex] = saturating_div(a_max, (varying unsigned int16) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (varying unsigned int16) 0; + } + else { + RET[programIndex] = (varying unsigned int16) 13107; + } +} diff --git a/tests/pdivus_vi32.ispc b/tests/pdivus_vi32.ispc new file mode 100644 index 00000000..3d6172db --- /dev/null +++ b/tests/pdivus_vi32.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_div(a_min, (varying unsigned int32) b); + } + else { + RET[programIndex] = saturating_div(a_max, (varying unsigned int32) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (varying unsigned int32) 0; + } + else { + RET[programIndex] = (varying unsigned int32) 858993459; + } +} diff --git a/tests/pdivus_vi64.ispc b/tests/pdivus_vi64.ispc new file mode 100644 index 00000000..e7e8ca20 --- /dev/null +++ b/tests/pdivus_vi64.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_div(a_min, (varying unsigned int64) b); + } + else { + RET[programIndex] = saturating_div(a_max, (varying unsigned int64) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (varying unsigned int64) 0; + } + else { + RET[programIndex] = (varying unsigned int64) 3689348814741910323; + } +} diff --git a/tests/pdivus_vi8.ispc b/tests/pdivus_vi8.ispc new file mode 100644 index 00000000..7bcd7f1d --- /dev/null +++ b/tests/pdivus_vi8.ispc @@ -0,0 +1,21 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying unsigned int8 a_max = 255, a_min = 0; // max and min unsigned int8 + if (programIndex % 2 == 0) { + RET[programIndex] = saturating_div(a_min, (varying unsigned int8) b); + } + else { + RET[programIndex] = saturating_div(a_max, (varying unsigned int8) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 2 == 0) { + RET[programIndex] = (varying unsigned int8) 0; + } + else { + RET[programIndex] = (varying unsigned int8) 51; + } +} diff --git a/tests/pmuls_i16.ispc b/tests/pmuls_i16.ispc new file mode 100644 index 00000000..f7e58a7f --- /dev/null +++ b/tests/pmuls_i16.ispc @@ -0,0 +1,28 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform int16 a_max = 32767, a_min = -32768; // max and min signed int16 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_mul(a_max, (uniform int16) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_mul(a_min, (uniform int16) b); + } + else { + RET[programIndex] = saturating_mul((uniform int16) b, + (uniform int16) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (uniform int16) 32767; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (uniform int16) -32768; + } + else { + RET[programIndex] = (uniform int16) 25; + } +} diff --git a/tests/pmuls_i32.ispc b/tests/pmuls_i32.ispc new file mode 100644 index 00000000..aca6324d --- /dev/null +++ b/tests/pmuls_i32.ispc @@ -0,0 +1,28 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_mul(a_max, (uniform int32) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_mul(a_min, (uniform int32) b); + } + else { + RET[programIndex] = saturating_mul((uniform int32) b, + (uniform int32) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (uniform int32) 2147483647; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (uniform int32) -2147483648; + } + else { + RET[programIndex] = (uniform int32) 25; + } +} diff --git a/tests/pmuls_i8.ispc b/tests/pmuls_i8.ispc new file mode 100644 index 00000000..0b14f5bb --- /dev/null +++ b/tests/pmuls_i8.ispc @@ -0,0 +1,29 @@ + + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform int8 a_max = 127, a_min = -128; // max and min signed int8 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_mul(a_max, (uniform int8) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_mul(a_min, (uniform int8) b); + } + else { + RET[programIndex] = saturating_mul((uniform int8) b, + (uniform int8) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (uniform int8) 127; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (uniform int8) -128; + } + else { + RET[programIndex] = (uniform int8) 25; + } +} diff --git a/tests/pmuls_vi16.ispc b/tests/pmuls_vi16.ispc new file mode 100644 index 00000000..b2f153e6 --- /dev/null +++ b/tests/pmuls_vi16.ispc @@ -0,0 +1,28 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying int16 a_max = 32767, a_min = -32768; // max and min signed int16 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_mul(a_max, (varying int16) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_mul(a_min, (varying int16) b); + } + else { + RET[programIndex] = saturating_mul((varying int16) b, + (varying int16) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (varying int16) 32767; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (varying int16) -32768; + } + else { + RET[programIndex] = (varying int16) 25; + } +} diff --git a/tests/pmuls_vi32.ispc b/tests/pmuls_vi32.ispc new file mode 100644 index 00000000..d4030e0d --- /dev/null +++ b/tests/pmuls_vi32.ispc @@ -0,0 +1,28 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_mul(a_max, (varying int32) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_mul(a_min, (varying int32) b); + } + else { + RET[programIndex] = saturating_mul((varying int32) b, + (varying int32) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (varying int32) 2147483647; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (varying int32) -2147483648; + } + else { + RET[programIndex] = (varying int32) 25; + } +} diff --git a/tests/pmuls_vi8.ispc b/tests/pmuls_vi8.ispc new file mode 100644 index 00000000..d8da3465 --- /dev/null +++ b/tests/pmuls_vi8.ispc @@ -0,0 +1,28 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying int8 a_max = 127, a_min = -128; // max and min signed int8 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_mul(a_max, (varying int8) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_mul(a_min, (varying int8) b); + } + else { + RET[programIndex] = saturating_mul((varying int8) b, + (varying int8) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (varying int8) 127; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (varying int8) -128; + } + else { + RET[programIndex] = (varying int8) 25; + } +} diff --git a/tests/pmulus_i16.ispc b/tests/pmulus_i16.ispc new file mode 100644 index 00000000..b01a1acd --- /dev/null +++ b/tests/pmulus_i16.ispc @@ -0,0 +1,28 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform unsigned int16 a_max = 65535, a_min = 0; // max and min unsigned int16 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_mul(a_max, (uniform unsigned int16) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_mul(a_min, (uniform unsigned int16) -b); + } + else { + RET[programIndex] = saturating_mul((uniform unsigned int16) b, + (uniform unsigned int16) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (uniform unsigned int16) 65535; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (uniform unsigned int16) 0; + } + else { + RET[programIndex] = (uniform unsigned int16) 25; + } +} diff --git a/tests/pmulus_i32.ispc b/tests/pmulus_i32.ispc new file mode 100644 index 00000000..d7116f12 --- /dev/null +++ b/tests/pmulus_i32.ispc @@ -0,0 +1,28 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_mul(a_max, (uniform unsigned int32) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_mul(a_min, (uniform unsigned int32) -b); + } + else { + RET[programIndex] = saturating_mul((uniform unsigned int32) b, + (uniform unsigned int32) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (uniform unsigned int32) 4294967295; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (uniform unsigned int32) 0; + } + else { + RET[programIndex] = (uniform unsigned int32) 25; + } +} diff --git a/tests/pmulus_i8.ispc b/tests/pmulus_i8.ispc new file mode 100644 index 00000000..f70fe716 --- /dev/null +++ b/tests/pmulus_i8.ispc @@ -0,0 +1,28 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + uniform unsigned int8 a_max = 255, a_min = 0; // max and min unsigned int8 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_mul(a_max, (uniform unsigned int8) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_mul(a_min, (uniform unsigned int8) -b); + } + else { + RET[programIndex] = saturating_mul((uniform unsigned int8) b, + (uniform unsigned int8) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (uniform unsigned int8) 255; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (uniform unsigned int8) 0; + } + else { + RET[programIndex] = (uniform unsigned int8) 25; + } +} diff --git a/tests/pmulus_vi16.ispc b/tests/pmulus_vi16.ispc new file mode 100644 index 00000000..256c0365 --- /dev/null +++ b/tests/pmulus_vi16.ispc @@ -0,0 +1,28 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying unsigned int16 a_max = 65535, a_min = 0; // max and min unsigned int16 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_mul(a_max, (varying unsigned int16) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_mul(a_min, (varying unsigned int16) -b); + } + else { + RET[programIndex] = saturating_mul((varying unsigned int16) b, + (varying unsigned int16) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (varying unsigned int16) 65535; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (varying unsigned int16) 0; + } + else { + RET[programIndex] = (varying unsigned int16) 25; + } +} diff --git a/tests/pmulus_vi32.ispc b/tests/pmulus_vi32.ispc new file mode 100644 index 00000000..b109d2cf --- /dev/null +++ b/tests/pmulus_vi32.ispc @@ -0,0 +1,28 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_mul(a_max, (varying unsigned int32) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_mul(a_min, (varying unsigned int32) -b); + } + else { + RET[programIndex] = saturating_mul((varying unsigned int32) b, + (varying unsigned int32) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (varying unsigned int32) 4294967295; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (varying unsigned int32) 0; + } + else { + RET[programIndex] = (varying unsigned int32) 25; + } +} diff --git a/tests/pmulus_vi8.ispc b/tests/pmulus_vi8.ispc new file mode 100644 index 00000000..1dc46697 --- /dev/null +++ b/tests/pmulus_vi8.ispc @@ -0,0 +1,28 @@ + +export uniform int width() { return programCount; } + +export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { + varying unsigned int8 a_max = 255, a_min = 0; // max and min unsigned int8 + if (programIndex % 3 == 0) { + RET[programIndex] = saturating_mul(a_max, (varying unsigned int8) b); + } + else if (programIndex % 3 == 1) { + RET[programIndex] = saturating_mul(a_min, (varying unsigned int8) -b); + } + else { + RET[programIndex] = saturating_mul((varying unsigned int8) b, + (varying unsigned int8) b); + } +} + +export void result(uniform float RET[]) { + if (programIndex % 3 == 0) { + RET[programIndex] = (varying unsigned int8) 255; + } + else if (programIndex % 3 == 1) { + RET[programIndex] = (varying unsigned int8) 0; + } + else { + RET[programIndex] = (varying unsigned int8) 25; + } +} From 7dd7020c5f8ab49fa5fec6e68e1347c1918b37d1 Mon Sep 17 00:00:00 2001 From: Vsevolod Livinskij Date: Thu, 20 Feb 2014 22:57:24 +0400 Subject: [PATCH 3/3] Dec constants was changed with hex constants. --- tests/padds_i32.ispc | 8 ++++---- tests/padds_i64.ispc | 8 ++++---- tests/padds_vi32.ispc | 8 ++++---- tests/padds_vi64.ispc | 8 ++++---- tests/paddus_i32.ispc | 4 ++-- tests/paddus_i64.ispc | 4 ++-- tests/paddus_vi32.ispc | 4 ++-- tests/paddus_vi64.ispc | 4 ++-- tests/pdivs_i16.ispc | 8 ++++---- tests/pdivs_i32.ispc | 8 ++++---- tests/pdivs_i64.ispc | 8 ++++---- tests/pdivs_i8.ispc | 8 ++++---- tests/pdivs_vi16.ispc | 8 ++++---- tests/pdivs_vi32.ispc | 8 ++++---- tests/pdivs_vi64.ispc | 8 ++++---- tests/pdivs_vi8.ispc | 8 ++++---- tests/pdivus_i16.ispc | 6 +++--- tests/pdivus_i32.ispc | 6 +++--- tests/pdivus_i64.ispc | 6 +++--- tests/pdivus_i8.ispc | 6 +++--- tests/pdivus_vi16.ispc | 6 +++--- tests/pdivus_vi32.ispc | 6 +++--- tests/pdivus_vi64.ispc | 6 +++--- tests/pdivus_vi8.ispc | 6 +++--- tests/pmuls_i16.ispc | 6 +++--- tests/pmuls_i32.ispc | 6 +++--- tests/pmuls_i8.ispc | 7 +++---- tests/pmuls_vi16.ispc | 6 +++--- tests/pmuls_vi32.ispc | 6 +++--- tests/pmuls_vi8.ispc | 6 +++--- tests/pmulus_i16.ispc | 6 +++--- tests/pmulus_i32.ispc | 6 +++--- tests/pmulus_i8.ispc | 6 +++--- tests/pmulus_vi16.ispc | 6 +++--- tests/pmulus_vi32.ispc | 6 +++--- tests/pmulus_vi8.ispc | 6 +++--- tests/psubs_i32.ispc | 8 ++++---- tests/psubs_i64.ispc | 8 ++++---- tests/psubs_vi32.ispc | 8 ++++---- tests/psubs_vi64.ispc | 8 ++++---- tests/psubus_i32.ispc | 6 +++--- tests/psubus_i64.ispc | 6 +++--- tests/psubus_vi32.ispc | 6 +++--- tests/psubus_vi64.ispc | 6 +++--- 44 files changed, 144 insertions(+), 145 deletions(-) diff --git a/tests/padds_i32.ispc b/tests/padds_i32.ispc index a92e640f..866f8496 100644 --- a/tests/padds_i32.ispc +++ b/tests/padds_i32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32 + uniform int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32 if (programIndex % 3 == 0) { RET[programIndex] = saturating_add(a_max, b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (uniform int32) 2147483647; + RET[programIndex] = (uniform int32) 0x7FFFFFFF; // max signed int32 } else if (programIndex % 3 == 1) { - RET[programIndex] = (uniform int32) -2147483648; + RET[programIndex] = (uniform int32) -0x80000000; // min signed int32 } else { - RET[programIndex] = (uniform int32) -2147483643; + RET[programIndex] = (uniform int32) -0x7FFFFFFB; // min + 5 } } diff --git a/tests/padds_i64.ispc b/tests/padds_i64.ispc index be21dc88..6b61b394 100644 --- a/tests/padds_i64.ispc +++ b/tests/padds_i64.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min signed int64 + uniform int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min signed int64 if (programIndex % 3 == 0) { RET[programIndex] = saturating_add(a_max, b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (uniform int64) 9223372036854775807; + RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFF; // max signed int64 } else if (programIndex % 3 == 1) { - RET[programIndex] = (uniform int64) -9223372036854775808; + RET[programIndex] = (uniform int64) -0x8000000000000000; // min signed int64 } else { - RET[programIndex] = (uniform int64) -9223372036854775803; + RET[programIndex] = (uniform int64) -0x7FFFFFFFFFFFFFFB; // min + 5 } } diff --git a/tests/padds_vi32.ispc b/tests/padds_vi32.ispc index f566f84b..a51bdad9 100644 --- a/tests/padds_vi32.ispc +++ b/tests/padds_vi32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32 + varying int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32 if (programIndex % 3 == 0) { RET[programIndex] = saturating_add(a_max, b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (varying int32) 2147483647; + RET[programIndex] = (varying int32) 0x7FFFFFFF; // max signed int32 } else if (programIndex % 3 == 1) { - RET[programIndex] = (varying int32) -2147483648; + RET[programIndex] = (varying int32) -0x80000000; // min signed int32 } else { - RET[programIndex] = (varying int32) -2147483643; + RET[programIndex] = (varying int32) -0x7FFFFFFB; // min + 5 } } diff --git a/tests/padds_vi64.ispc b/tests/padds_vi64.ispc index c8492fb4..9b577a79 100644 --- a/tests/padds_vi64.ispc +++ b/tests/padds_vi64.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min signed int64 + varying int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min signed int64 if (programIndex % 3 == 0) { RET[programIndex] = saturating_add(a_max, b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (varying int64) 9223372036854775807; + RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFF; // max signed int64 } else if (programIndex % 3 == 1) { - RET[programIndex] = (varying int64) -9223372036854775808; + RET[programIndex] = (varying int64) -0x8000000000000000; // min signed int64 } else { - RET[programIndex] = (varying int64) -9223372036854775803; + RET[programIndex] = (varying int64) -0x7FFFFFFFFFFFFFFB; // min + 5 } } diff --git a/tests/paddus_i32.ispc b/tests/paddus_i32.ispc index 2745b5eb..2a159340 100644 --- a/tests/paddus_i32.ispc +++ b/tests/paddus_i32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + uniform unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32 if (programIndex % 2 == 0) { RET[programIndex] = saturating_add(a_max, b); } @@ -13,7 +13,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (uniform unsigned int32) 4294967295; + RET[programIndex] = (uniform unsigned int32) 0xFFFFFFFF; // max unsigned int32 } else { RET[programIndex] = (uniform unsigned int32) 5; diff --git a/tests/paddus_i64.ispc b/tests/paddus_i64.ispc index ff63307d..38b5c4fe 100644 --- a/tests/paddus_i64.ispc +++ b/tests/paddus_i64.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64 + uniform unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64 if (programIndex % 2 == 0) { RET[programIndex] = saturating_add(a_max, b); } @@ -13,7 +13,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (uniform unsigned int64) 18446744073709551615; + RET[programIndex] = (uniform unsigned int64) 0xFFFFFFFFFFFFFFFF; // max unsigned int64 } else { RET[programIndex] = (uniform unsigned int64) 5; diff --git a/tests/paddus_vi32.ispc b/tests/paddus_vi32.ispc index eaa4097f..555d9837 100644 --- a/tests/paddus_vi32.ispc +++ b/tests/paddus_vi32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + varying unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32 if (programIndex % 2 == 0) { RET[programIndex] = saturating_add(a_max, b); } @@ -13,7 +13,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (varying unsigned int32) 4294967295; + RET[programIndex] = (varying unsigned int32) 0xFFFFFFFF; // max unsigned int32 } else { RET[programIndex] = (varying unsigned int32) 5; diff --git a/tests/paddus_vi64.ispc b/tests/paddus_vi64.ispc index 3694125e..cf99be72 100644 --- a/tests/paddus_vi64.ispc +++ b/tests/paddus_vi64.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64 + varying unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64 if (programIndex % 2 == 0) { RET[programIndex] = saturating_add(a_max, b); } @@ -13,7 +13,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (varying unsigned int64) 18446744073709551615; + RET[programIndex] = (varying unsigned int64) 0xFFFFFFFFFFFFFFFF; // max unsigned int64 } else { RET[programIndex] = (varying unsigned int64) 5; diff --git a/tests/pdivs_i16.ispc b/tests/pdivs_i16.ispc index b9b5858f..7dede2a7 100644 --- a/tests/pdivs_i16.ispc +++ b/tests/pdivs_i16.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform int16 a_max = 32767, a_min = -32768; // max and min signed int16 + uniform int16 a_max = 0x7FFF, a_min = -0x8000; // max and min signed int16 if (programIndex % 3 == 0) { RET[programIndex] = saturating_div(a_max, (uniform int16) b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (uniform int16) 6553.4; + RET[programIndex] = (uniform int16) 6553.4; // max / 5 } else if (programIndex % 3 == 1) { - RET[programIndex] = (uniform int16) -6553.6; + RET[programIndex] = (uniform int16) -6553.6; // min / 5 } else { - RET[programIndex] = (uniform int16) 32767; + RET[programIndex] = (uniform int16) 0x7FFF; // max signed int16 } } diff --git a/tests/pdivs_i32.ispc b/tests/pdivs_i32.ispc index 99760828..d6d1d97d 100644 --- a/tests/pdivs_i32.ispc +++ b/tests/pdivs_i32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32 + uniform int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32 if (programIndex % 3 == 0) { RET[programIndex] = saturating_div(a_max, (uniform int32) b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (uniform int32) 429496729.4; + RET[programIndex] = (uniform int32) 429496729.4; // max / 5 } else if (programIndex % 3 == 1) { - RET[programIndex] = (uniform int32) -429496729.6; + RET[programIndex] = (uniform int32) -429496729.6; // min / 5 } else { - RET[programIndex] = (uniform int32) 2147483647; + RET[programIndex] = (uniform int32) 0x7FFFFFFF; // max signed int32 } } diff --git a/tests/pdivs_i64.ispc b/tests/pdivs_i64.ispc index e0de47f7..4a3bb268 100644 --- a/tests/pdivs_i64.ispc +++ b/tests/pdivs_i64.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min signed int64 + uniform int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min signed int64 if (programIndex % 3 == 0) { RET[programIndex] = saturating_div(a_max, (uniform int64) b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (uniform int64) 1844674407370955161.4; + RET[programIndex] = (uniform int64) 1844674407370955161.4; // max / 5 } else if (programIndex % 3 == 1) { - RET[programIndex] = (uniform int64) -1844674407370955161.6; + RET[programIndex] = (uniform int64) -1844674407370955161.6; // min / 5 } else { - RET[programIndex] = (uniform int64) 9223372036854775807; + RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFF; // max signed int64 } } diff --git a/tests/pdivs_i8.ispc b/tests/pdivs_i8.ispc index c68dcd64..0fa71253 100644 --- a/tests/pdivs_i8.ispc +++ b/tests/pdivs_i8.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform int8 a_max = 127, a_min = -128; // max and min signed int8 + uniform int8 a_max = 0x7F, a_min = -0x80; // max and min signed int8 if (programIndex % 3 == 0) { RET[programIndex] = saturating_div(a_max, (uniform int8) b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (uniform int8) 25.4; + RET[programIndex] = (uniform int8) 25.4; // max / 5 } else if (programIndex % 3 == 1) { - RET[programIndex] = (uniform int8) -25.6; + RET[programIndex] = (uniform int8) -25.6; // min / 5 } else { - RET[programIndex] = (uniform int8) 127; + RET[programIndex] = (uniform int8) 0x7F; // max signed int8 } } diff --git a/tests/pdivs_vi16.ispc b/tests/pdivs_vi16.ispc index 0b119672..482fbfcb 100644 --- a/tests/pdivs_vi16.ispc +++ b/tests/pdivs_vi16.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying int16 a_max = 32767, a_min = -32768; // max and min signed int16 + varying int16 a_max = 0x7FFF, a_min = -0x8000; // max and min signed int16 if (programIndex % 3 == 0) { RET[programIndex] = saturating_div(a_max, (varying int16) b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (varying int16) 6553.4; + RET[programIndex] = (varying int16) 6553.4; // max / 5 } else if (programIndex % 3 == 1) { - RET[programIndex] = (varying int16) -6553.6; + RET[programIndex] = (varying int16) -6553.6; // min / 5 } else { - RET[programIndex] = (varying int16) 32767; + RET[programIndex] = (varying int16) 0x7FFF; // max signed int16 } } diff --git a/tests/pdivs_vi32.ispc b/tests/pdivs_vi32.ispc index 4f6b0bae..1c699b68 100644 --- a/tests/pdivs_vi32.ispc +++ b/tests/pdivs_vi32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32 + varying int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32 if (programIndex % 3 == 0) { RET[programIndex] = saturating_div(a_max, (varying int32) b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (varying int32) 429496729.4; + RET[programIndex] = (varying int32) 429496729.4; // max / 5 } else if (programIndex % 3 == 1) { - RET[programIndex] = (varying int32) -429496729.6; + RET[programIndex] = (varying int32) -429496729.6; // min / 5 } else { - RET[programIndex] = (varying int32) 2147483647; + RET[programIndex] = (varying int32) 0x7FFFFFFF; // max signed int32 } } diff --git a/tests/pdivs_vi64.ispc b/tests/pdivs_vi64.ispc index cb4fba70..00913ea3 100644 --- a/tests/pdivs_vi64.ispc +++ b/tests/pdivs_vi64.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min signed int64 + varying int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min signed int64 if (programIndex % 3 == 0) { RET[programIndex] = saturating_div(a_max, (varying int64) b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (varying int64) 1844674407370955161.4; + RET[programIndex] = (varying int64) 1844674407370955161.4; // max / 5 } else if (programIndex % 3 == 1) { - RET[programIndex] = (varying int64) -1844674407370955161.6; + RET[programIndex] = (varying int64) -1844674407370955161.6; // min / 5 } else { - RET[programIndex] = (varying int64) 9223372036854775807; + RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFF; // max signed int64 } } diff --git a/tests/pdivs_vi8.ispc b/tests/pdivs_vi8.ispc index 7b021645..3e039a01 100644 --- a/tests/pdivs_vi8.ispc +++ b/tests/pdivs_vi8.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying int8 a_max = 127, a_min = -128; // max and min signed int8 + varying int8 a_max = 0x7F, a_min = -0x80; // max and min signed int8 if (programIndex % 3 == 0) { RET[programIndex] = saturating_div(a_max, (varying int8) b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (varying int8) 25.4; + RET[programIndex] = (varying int8) 25.4; // max / 5 } else if (programIndex % 3 == 1) { - RET[programIndex] = (varying int8) -25.6; + RET[programIndex] = (varying int8) -25.6; // min / 5 } else { - RET[programIndex] = (varying int8) 127; + RET[programIndex] = (varying int8) 0x7F; // max signed int8 } } diff --git a/tests/pdivus_i16.ispc b/tests/pdivus_i16.ispc index 827eedfc..c7573d78 100644 --- a/tests/pdivus_i16.ispc +++ b/tests/pdivus_i16.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform unsigned int16 a_max = 65535, a_min = 0; // max and min unsigned int16 + uniform unsigned int16 a_max = 0xFFFF, a_min = 0; // max and min unsigned int16 if (programIndex % 2 == 0) { RET[programIndex] = saturating_div(a_min, (uniform unsigned int16) b); } @@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (uniform unsigned int16) 0; + RET[programIndex] = (uniform unsigned int16) 0; // min unsigned int16 } else { - RET[programIndex] = (uniform unsigned int16) 13107; + RET[programIndex] = (uniform unsigned int16) 0x3333; // max unsigned int16 / 5 } } diff --git a/tests/pdivus_i32.ispc b/tests/pdivus_i32.ispc index ec4c97be..c11b68fe 100644 --- a/tests/pdivus_i32.ispc +++ b/tests/pdivus_i32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + uniform unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32 if (programIndex % 2 == 0) { RET[programIndex] = saturating_div(a_min, (uniform unsigned int32) b); } @@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (uniform unsigned int32) 0; + RET[programIndex] = (uniform unsigned int32) 0; // min unsigned int32 } else { - RET[programIndex] = (uniform unsigned int32) 858993459; + RET[programIndex] = (uniform unsigned int32) 0x33333333; // max unsigned int32 / 5 } } diff --git a/tests/pdivus_i64.ispc b/tests/pdivus_i64.ispc index ddc4d866..51354ce7 100644 --- a/tests/pdivus_i64.ispc +++ b/tests/pdivus_i64.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64 + uniform unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64 if (programIndex % 2 == 0) { RET[programIndex] = saturating_div(a_min, (uniform unsigned int64) b); } @@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (uniform unsigned int64) 0; + RET[programIndex] = (uniform unsigned int64) 0; // min unsigned int64 } else { - RET[programIndex] = (uniform unsigned int64) 3689348814741910323; + RET[programIndex] = (uniform unsigned int64) 0x3333333333333333; // max unsigned int64 / 5 } } diff --git a/tests/pdivus_i8.ispc b/tests/pdivus_i8.ispc index 0c133a1d..1b509c30 100644 --- a/tests/pdivus_i8.ispc +++ b/tests/pdivus_i8.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform unsigned int8 a_max = 255, a_min = 0; // max and min unsigned int8 + uniform unsigned int8 a_max = 0xFF, a_min = 0; // max and min unsigned int8 if (programIndex % 2 == 0) { RET[programIndex] = saturating_div(a_min, (uniform unsigned int8) b); } @@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (uniform unsigned int8) 0; + RET[programIndex] = (uniform unsigned int8) 0; // min unsigned int8 } else { - RET[programIndex] = (uniform unsigned int8) 51; + RET[programIndex] = (uniform unsigned int8) 0x33; // max unsigned int8 / 5 } } diff --git a/tests/pdivus_vi16.ispc b/tests/pdivus_vi16.ispc index 754399db..71696f7e 100644 --- a/tests/pdivus_vi16.ispc +++ b/tests/pdivus_vi16.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying unsigned int16 a_max = 65535, a_min = 0; // max and min unsigned int16 + varying unsigned int16 a_max = 0xFFFF, a_min = 0; // max and min unsigned int16 if (programIndex % 2 == 0) { RET[programIndex] = saturating_div(a_min, (varying unsigned int16) b); } @@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (varying unsigned int16) 0; + RET[programIndex] = (varying unsigned int16) 0; // min unsigned int16 } else { - RET[programIndex] = (varying unsigned int16) 13107; + RET[programIndex] = (varying unsigned int16) 0x3333; // max unsigned int16 / 5 } } diff --git a/tests/pdivus_vi32.ispc b/tests/pdivus_vi32.ispc index 3d6172db..0c8a8f25 100644 --- a/tests/pdivus_vi32.ispc +++ b/tests/pdivus_vi32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + varying unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32 if (programIndex % 2 == 0) { RET[programIndex] = saturating_div(a_min, (varying unsigned int32) b); } @@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (varying unsigned int32) 0; + RET[programIndex] = (varying unsigned int32) 0; // min unsigned int32 } else { - RET[programIndex] = (varying unsigned int32) 858993459; + RET[programIndex] = (varying unsigned int32) 0x33333333; // max unsigned int32 / 5 } } diff --git a/tests/pdivus_vi64.ispc b/tests/pdivus_vi64.ispc index e7e8ca20..1aef75f7 100644 --- a/tests/pdivus_vi64.ispc +++ b/tests/pdivus_vi64.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64 + varying unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64 if (programIndex % 2 == 0) { RET[programIndex] = saturating_div(a_min, (varying unsigned int64) b); } @@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (varying unsigned int64) 0; + RET[programIndex] = (varying unsigned int64) 0; // min unsigned int64 } else { - RET[programIndex] = (varying unsigned int64) 3689348814741910323; + RET[programIndex] = (varying unsigned int64) 0x3333333333333333; // max unsigned int64 / 5 } } diff --git a/tests/pdivus_vi8.ispc b/tests/pdivus_vi8.ispc index 7bcd7f1d..f4a5adaf 100644 --- a/tests/pdivus_vi8.ispc +++ b/tests/pdivus_vi8.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying unsigned int8 a_max = 255, a_min = 0; // max and min unsigned int8 + varying unsigned int8 a_max = 0xFF, a_min = 0; // max and min unsigned int8 if (programIndex % 2 == 0) { RET[programIndex] = saturating_div(a_min, (varying unsigned int8) b); } @@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (varying unsigned int8) 0; + RET[programIndex] = (varying unsigned int8) 0; // min unsigned int8 } else { - RET[programIndex] = (varying unsigned int8) 51; + RET[programIndex] = (varying unsigned int8) 0x33; // max unsigned int8 / 5 } } diff --git a/tests/pmuls_i16.ispc b/tests/pmuls_i16.ispc index f7e58a7f..38e8794f 100644 --- a/tests/pmuls_i16.ispc +++ b/tests/pmuls_i16.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform int16 a_max = 32767, a_min = -32768; // max and min signed int16 + uniform int16 a_max = 0x7FFF, a_min = -0x8000; // max and min signed int16 if (programIndex % 3 == 0) { RET[programIndex] = saturating_mul(a_max, (uniform int16) b); } @@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (uniform int16) 32767; + RET[programIndex] = (uniform int16) 0x7FFF; // max signed int16 } else if (programIndex % 3 == 1) { - RET[programIndex] = (uniform int16) -32768; + RET[programIndex] = (uniform int16) -0x8000; // min signed int16 } else { RET[programIndex] = (uniform int16) 25; diff --git a/tests/pmuls_i32.ispc b/tests/pmuls_i32.ispc index aca6324d..51a2f6ba 100644 --- a/tests/pmuls_i32.ispc +++ b/tests/pmuls_i32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32 + uniform int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32 if (programIndex % 3 == 0) { RET[programIndex] = saturating_mul(a_max, (uniform int32) b); } @@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (uniform int32) 2147483647; + RET[programIndex] = (uniform int32) 0x7FFFFFFF; // max signed int32 } else if (programIndex % 3 == 1) { - RET[programIndex] = (uniform int32) -2147483648; + RET[programIndex] = (uniform int32) -0x80000000; // min signed int32 } else { RET[programIndex] = (uniform int32) 25; diff --git a/tests/pmuls_i8.ispc b/tests/pmuls_i8.ispc index 0b14f5bb..aa2419c7 100644 --- a/tests/pmuls_i8.ispc +++ b/tests/pmuls_i8.ispc @@ -1,9 +1,8 @@ - export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform int8 a_max = 127, a_min = -128; // max and min signed int8 + uniform int8 a_max = 0x7F, a_min = -0x80; // max and min signed int8 if (programIndex % 3 == 0) { RET[programIndex] = saturating_mul(a_max, (uniform int8) b); } @@ -18,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (uniform int8) 127; + RET[programIndex] = (uniform int8) 0x7F; // max signed int8 } else if (programIndex % 3 == 1) { - RET[programIndex] = (uniform int8) -128; + RET[programIndex] = (uniform int8) -0x80; // min signed int8 } else { RET[programIndex] = (uniform int8) 25; diff --git a/tests/pmuls_vi16.ispc b/tests/pmuls_vi16.ispc index b2f153e6..4d467b28 100644 --- a/tests/pmuls_vi16.ispc +++ b/tests/pmuls_vi16.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying int16 a_max = 32767, a_min = -32768; // max and min signed int16 + varying int16 a_max = 0x7FFF, a_min = -0x8000; // max and min signed int16 if (programIndex % 3 == 0) { RET[programIndex] = saturating_mul(a_max, (varying int16) b); } @@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (varying int16) 32767; + RET[programIndex] = (varying int16) 0x7FFF; // max signed int16 } else if (programIndex % 3 == 1) { - RET[programIndex] = (varying int16) -32768; + RET[programIndex] = (varying int16) -0x8000; // min signed int16 } else { RET[programIndex] = (varying int16) 25; diff --git a/tests/pmuls_vi32.ispc b/tests/pmuls_vi32.ispc index d4030e0d..00a178da 100644 --- a/tests/pmuls_vi32.ispc +++ b/tests/pmuls_vi32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32 + varying int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32 if (programIndex % 3 == 0) { RET[programIndex] = saturating_mul(a_max, (varying int32) b); } @@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (varying int32) 2147483647; + RET[programIndex] = (varying int32) 0x7FFFFFFF; // max signed int32 } else if (programIndex % 3 == 1) { - RET[programIndex] = (varying int32) -2147483648; + RET[programIndex] = (varying int32) -0x80000000; // min signed int32 } else { RET[programIndex] = (varying int32) 25; diff --git a/tests/pmuls_vi8.ispc b/tests/pmuls_vi8.ispc index d8da3465..33975f51 100644 --- a/tests/pmuls_vi8.ispc +++ b/tests/pmuls_vi8.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying int8 a_max = 127, a_min = -128; // max and min signed int8 + varying int8 a_max = 0x7F, a_min = -0x80; // max and min signed int8 if (programIndex % 3 == 0) { RET[programIndex] = saturating_mul(a_max, (varying int8) b); } @@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (varying int8) 127; + RET[programIndex] = (varying int8) 0x7F; // max signed int8 } else if (programIndex % 3 == 1) { - RET[programIndex] = (varying int8) -128; + RET[programIndex] = (varying int8) -0x80; // min signed int8 } else { RET[programIndex] = (varying int8) 25; diff --git a/tests/pmulus_i16.ispc b/tests/pmulus_i16.ispc index b01a1acd..bbf9182f 100644 --- a/tests/pmulus_i16.ispc +++ b/tests/pmulus_i16.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform unsigned int16 a_max = 65535, a_min = 0; // max and min unsigned int16 + uniform unsigned int16 a_max = 0xFFFF, a_min = 0; // max and min unsigned int16 if (programIndex % 3 == 0) { RET[programIndex] = saturating_mul(a_max, (uniform unsigned int16) b); } @@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (uniform unsigned int16) 65535; + RET[programIndex] = (uniform unsigned int16) 0xFFFF; // max unsigned int16 } else if (programIndex % 3 == 1) { - RET[programIndex] = (uniform unsigned int16) 0; + RET[programIndex] = (uniform unsigned int16) 0; // min unsigned int16 } else { RET[programIndex] = (uniform unsigned int16) 25; diff --git a/tests/pmulus_i32.ispc b/tests/pmulus_i32.ispc index d7116f12..3f926d2d 100644 --- a/tests/pmulus_i32.ispc +++ b/tests/pmulus_i32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + uniform unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32 if (programIndex % 3 == 0) { RET[programIndex] = saturating_mul(a_max, (uniform unsigned int32) b); } @@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (uniform unsigned int32) 4294967295; + RET[programIndex] = (uniform unsigned int32) 0xFFFFFFFF; // max unsigned int32 } else if (programIndex % 3 == 1) { - RET[programIndex] = (uniform unsigned int32) 0; + RET[programIndex] = (uniform unsigned int32) 0; // min unsigned int32 } else { RET[programIndex] = (uniform unsigned int32) 25; diff --git a/tests/pmulus_i8.ispc b/tests/pmulus_i8.ispc index f70fe716..71504ae3 100644 --- a/tests/pmulus_i8.ispc +++ b/tests/pmulus_i8.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform unsigned int8 a_max = 255, a_min = 0; // max and min unsigned int8 + uniform unsigned int8 a_max = 0xFF, a_min = 0; // max and min unsigned int8 if (programIndex % 3 == 0) { RET[programIndex] = saturating_mul(a_max, (uniform unsigned int8) b); } @@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (uniform unsigned int8) 255; + RET[programIndex] = (uniform unsigned int8) 0xFF; // max unsigned int8 } else if (programIndex % 3 == 1) { - RET[programIndex] = (uniform unsigned int8) 0; + RET[programIndex] = (uniform unsigned int8) 0; // min unsigned int8 } else { RET[programIndex] = (uniform unsigned int8) 25; diff --git a/tests/pmulus_vi16.ispc b/tests/pmulus_vi16.ispc index 256c0365..427bf632 100644 --- a/tests/pmulus_vi16.ispc +++ b/tests/pmulus_vi16.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying unsigned int16 a_max = 65535, a_min = 0; // max and min unsigned int16 + varying unsigned int16 a_max = 0xFFFF, a_min = 0; // max and min unsigned int16 if (programIndex % 3 == 0) { RET[programIndex] = saturating_mul(a_max, (varying unsigned int16) b); } @@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (varying unsigned int16) 65535; + RET[programIndex] = (varying unsigned int16) 0xFFFF; // max unsigned int16 } else if (programIndex % 3 == 1) { - RET[programIndex] = (varying unsigned int16) 0; + RET[programIndex] = (varying unsigned int16) 0; // min unsigned int16 } else { RET[programIndex] = (varying unsigned int16) 25; diff --git a/tests/pmulus_vi32.ispc b/tests/pmulus_vi32.ispc index b109d2cf..0e5a09b3 100644 --- a/tests/pmulus_vi32.ispc +++ b/tests/pmulus_vi32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + varying unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32 if (programIndex % 3 == 0) { RET[programIndex] = saturating_mul(a_max, (varying unsigned int32) b); } @@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (varying unsigned int32) 4294967295; + RET[programIndex] = (varying unsigned int32) 0xFFFFFFFF; // max unsigned int32 } else if (programIndex % 3 == 1) { - RET[programIndex] = (varying unsigned int32) 0; + RET[programIndex] = (varying unsigned int32) 0; // min unsigned int32 } else { RET[programIndex] = (varying unsigned int32) 25; diff --git a/tests/pmulus_vi8.ispc b/tests/pmulus_vi8.ispc index 1dc46697..d378ee52 100644 --- a/tests/pmulus_vi8.ispc +++ b/tests/pmulus_vi8.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying unsigned int8 a_max = 255, a_min = 0; // max and min unsigned int8 + varying unsigned int8 a_max = 0xFF, a_min = 0; // max and min unsigned int8 if (programIndex % 3 == 0) { RET[programIndex] = saturating_mul(a_max, (varying unsigned int8) b); } @@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (varying unsigned int8) 255; + RET[programIndex] = (varying unsigned int8) 0xFF; // max unsigned int8 } else if (programIndex % 3 == 1) { - RET[programIndex] = (varying unsigned int8) 0; + RET[programIndex] = (varying unsigned int8) 0; // min unsigned int8 } else { RET[programIndex] = (varying unsigned int8) 25; diff --git a/tests/psubs_i32.ispc b/tests/psubs_i32.ispc index 9fefd861..7b4bad63 100644 --- a/tests/psubs_i32.ispc +++ b/tests/psubs_i32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform int32 a_max = 2147483647, a_min = -2147483648; // max and min int32 + uniform int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min int32 if (programIndex % 3 == 0) { RET[programIndex] = saturating_sub(a_min, b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (uniform int32) -2147483648; + RET[programIndex] = (uniform int32) -0x80000000; // min signed int32 } else if (programIndex % 3 == 1) { - RET[programIndex] = (uniform int32) 2147483647; + RET[programIndex] = (uniform int32) 0x7FFFFFFF; // max signed int32 } else { - RET[programIndex] = (uniform int32) 2147483642; + RET[programIndex] = (uniform int32) 0x7FFFFFFA; } } diff --git a/tests/psubs_i64.ispc b/tests/psubs_i64.ispc index b1e061bc..dd7b5715 100644 --- a/tests/psubs_i64.ispc +++ b/tests/psubs_i64.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min int64 + uniform int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min int64 if (programIndex % 3 == 0) { RET[programIndex] = saturating_sub(a_min, b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (uniform int64) -9223372036854775808; + RET[programIndex] = (uniform int64) -0x8000000000000000; // min signed int64 } else if (programIndex % 3 == 1) { - RET[programIndex] = (uniform int64) 9223372036854775807; + RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFF; // max signed int64 } else { - RET[programIndex] = (uniform int64) 9223372036854775802; + RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFA; } } diff --git a/tests/psubs_vi32.ispc b/tests/psubs_vi32.ispc index 1dd2720c..6c3800ec 100644 --- a/tests/psubs_vi32.ispc +++ b/tests/psubs_vi32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying int32 a_max = 2147483647, a_min = -2147483648; // max and min int32 + varying int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min int32 if (programIndex % 3 == 0) { RET[programIndex] = saturating_sub(a_min, b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (varying int32) -2147483648; + RET[programIndex] = (varying int32) -0x80000000; // min signed int32 } else if (programIndex % 3 == 1) { - RET[programIndex] = (varying int32) 2147483647; + RET[programIndex] = (varying int32) 0x7FFFFFFF; // max signed int32 } else { - RET[programIndex] = (varying int32) 2147483642; + RET[programIndex] = (varying int32) 0x7FFFFFFA; } } diff --git a/tests/psubs_vi64.ispc b/tests/psubs_vi64.ispc index 75a9711e..887134b4 100644 --- a/tests/psubs_vi64.ispc +++ b/tests/psubs_vi64.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min int64 + varying int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min int64 if (programIndex % 3 == 0) { RET[programIndex] = saturating_sub(a_min, b); } @@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 3 == 0) { - RET[programIndex] = (varying int64) -9223372036854775808; + RET[programIndex] = (varying int64) -0x8000000000000000; // min signed int64 } else if (programIndex % 3 == 1) { - RET[programIndex] = (varying int64) 9223372036854775807; + RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFF; // max signed int64 } else { - RET[programIndex] = (varying int64) 9223372036854775802; + RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFA; } } diff --git a/tests/psubus_i32.ispc b/tests/psubus_i32.ispc index dc188fc3..a3352d5d 100644 --- a/tests/psubus_i32.ispc +++ b/tests/psubus_i32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + uniform unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32 if (programIndex % 2 == 0) { RET[programIndex] = saturating_sub(a_min, b); } @@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (uniform unsigned int32) 0; + RET[programIndex] = (uniform unsigned int32) 0; // min unsigned int32 } else { - RET[programIndex] = (uniform unsigned int32) 4294967290; + RET[programIndex] = (uniform unsigned int32) 0xFFFFFFFB; // max unsigned int32 - 5 } } diff --git a/tests/psubus_i64.ispc b/tests/psubus_i64.ispc index bca59a40..d1a6ee51 100644 --- a/tests/psubus_i64.ispc +++ b/tests/psubus_i64.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - uniform unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64 + uniform unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64 if (programIndex % 2 == 0) { RET[programIndex] = saturating_sub(a_min, b); } @@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (uniform unsigned int64) 0; + RET[programIndex] = (uniform unsigned int64) 0; // min unsigned int64 } else { - RET[programIndex] = (uniform unsigned int64) 18446744073709551610; + RET[programIndex] = (uniform unsigned int64) 0xFFFFFFFFFFFFFFFB; // max unsigned int64 - 5 } } diff --git a/tests/psubus_vi32.ispc b/tests/psubus_vi32.ispc index dffcaeb4..22a42963 100644 --- a/tests/psubus_vi32.ispc +++ b/tests/psubus_vi32.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32 + varying unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32 if (programIndex % 2 == 0) { RET[programIndex] = saturating_sub(a_min, b); } @@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (varying unsigned int32) 0; + RET[programIndex] = (varying unsigned int32) 0; // min unsigned int32 } else { - RET[programIndex] = (varying unsigned int32) 4294967290; + RET[programIndex] = (varying unsigned int32) 0xFFFFFFFB; // max unsigned int32 - 5 } } diff --git a/tests/psubus_vi64.ispc b/tests/psubus_vi64.ispc index e56d8972..870d468a 100644 --- a/tests/psubus_vi64.ispc +++ b/tests/psubus_vi64.ispc @@ -2,7 +2,7 @@ export uniform int width() { return programCount; } export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { - varying unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64 + varying unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64 if (programIndex % 2 == 0) { RET[programIndex] = saturating_sub(a_min, b); } @@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) { export void result(uniform float RET[]) { if (programIndex % 2 == 0) { - RET[programIndex] = (varying unsigned int64) 0; + RET[programIndex] = (varying unsigned int64) 0; // min unsigned int64 } else { - RET[programIndex] = (varying unsigned int64) 18446744073709551610; + RET[programIndex] = (varying unsigned int64) 0xFFFFFFFFFFFFFFFB; // max unsigned int64 - 5 } }