Rename in test files

Author: mborland

test/Jamfile

@@ -62,25 +62,25 @@ run github_issue_900.cpp ;
 run github_issue_911.cpp ;
 run link_1.cpp link_2.cpp link_3.cpp ;
 run quick.cpp ;
-run random_decimal32_comp.cpp ;
-run random_decimal32_fast_comp.cpp ;
-run random_decimal32_fast_math.cpp ;
-run random_decimal32_math.cpp ;
-run random_decimal64_comp.cpp ;
-run random_decimal64_fast_comp.cpp ;
-run random_decimal64_fast_math.cpp ;
-run random_decimal64_math.cpp ;
-run random_decimal128_comp.cpp ;
-run random_decimal128_fast_comp.cpp ;
-run random_decimal128_fast_math.cpp ;
-run random_decimal128_math.cpp ;
+run random_decimal32_t_comp.cpp ;
+run random_decimal_fast32_t_comp.cpp ;
+run random_decimal_fast32_t_math.cpp ;
+run random_decimal32_t_math.cpp ;
+run random_decimal64_t_comp.cpp ;
+run random_decimal_fast64_t_comp.cpp ;
+run random_decimal_fast64_t_math.cpp ;
+run random_decimal64_t_math.cpp ;
+run random_decimal128_t_comp.cpp ;
+run random_decimal_fast128_t_comp.cpp ;
+run random_decimal_fast128_t_math.cpp ;
+run random_decimal128_t_math.cpp ;
 run random_mixed_decimal_comp.cpp ;
 run random_mixed_decimal_math.cpp ;
-run roundtrip_decimal32.cpp ;
-run roundtrip_decimal32_fast.cpp ;
-run roundtrip_decimal64.cpp ;
-run roundtrip_decimal128.cpp ;
-run roundtrip_decimal128_fast.cpp ;
+run roundtrip_decimal32_t.cpp ;
+run roundtrip_decimal_fast32_t.cpp ;
+run roundtrip_decimal64_t.cpp ;
+run roundtrip_decimal128_t.cpp ;
+run roundtrip_decimal_fast128_t.cpp ;
 run test_acos.cpp ;
 run test_acosh.cpp ;
 run test_asin.cpp ;
@@ -99,15 +99,15 @@ run test_cbrt.cpp ;
 run test_cmath.cpp ;
 run test_constants.cpp ;
 run test_cosh.cpp ;
-#run test_decimal32.cpp ;
-run test_decimal32_fast_basis.cpp ;
-run test_decimal32_fast_stream.cpp ;
-run test_decimal32_stream.cpp ;
-#run test_decimal64_basis.cpp ;
-run test_decimal64_fast_basis.cpp ;
-run test_decimal64_fast_stream.cpp ;
-run test_decimal64_stream.cpp ;
-#run test_decimal128_basis.cpp ;
+#run test_decimal32_t.cpp ;
+run test_decimal_fast32_t_basis.cpp ;
+run test_decimal_fast32_t_stream.cpp ;
+run test_decimal32_t_stream.cpp ;
+#run test_decimal64_t_basis.cpp ;
+run test_decimal_fast64_t_basis.cpp ;
+run test_decimal_fast64_t_stream.cpp ;
+run test_decimal64_t_stream.cpp ;
+#run test_decimal128_t_basis.cpp ;
 run test_decimal_quantum.cpp ;
 run test_dpd_conversions.cpp ;
 run test_edges_and_behave.cpp ;
@@ -132,11 +132,11 @@ run test_git_issue_266.cpp ;
 run test_git_issue_271.cpp ;
 run test_hash.cpp ;
 run test_hermite.cpp ;
-compile-fail test_illegal_decimal32_fast_implicit_conversions.cpp ;
-compile-fail test_illegal_decimal32_implicit_conversions.cpp ;
-compile-fail test_illegal_decimal64_fast_implicit_conversions.cpp ;
-compile-fail test_illegal_decimal64_implicit_conversions.cpp ;
-compile-fail test_illegal_decimal128_implicit_conversions.cpp ;
+compile-fail test_illegal_decimal_fast32_t_implicit_conversions.cpp ;
+compile-fail test_illegal_decimal32_t_implicit_conversions.cpp ;
+compile-fail test_illegal_decimal_fast64_t_implicit_conversions.cpp ;
+compile-fail test_illegal_decimal64_t_implicit_conversions.cpp ;
+compile-fail test_illegal_decimal128_t_implicit_conversions.cpp ;
 run test_implicit_integral_conversion.cpp ;
 run test_laguerre.cpp ;
 run test_legal_implicit_conversions.cpp ;
@@ -184,12 +184,12 @@ compile compile_tests/charconv_compile.cpp ;
 compile compile_tests/cmath_compile.cpp ;
 compile compile_tests/cstdio_compile.cpp ;
 compile compile_tests/cstdlib_compile.cpp ;
-compile compile_tests/decimal32_compile.cpp ;
-compile compile_tests/decimal32_fast_compile.cpp ;
-compile compile_tests/decimal64_compile.cpp ;
-compile compile_tests/decimal64_fast_compile.cpp ;
-compile compile_tests/decimal128_compile.cpp ;
-compile compile_tests/decimal128_fast_compile.cpp ;
+compile compile_tests/decimal32_t_compile.cpp ;
+compile compile_tests/decimal_fast32_t_compile.cpp ;
+compile compile_tests/decimal64_t_compile.cpp ;
+compile compile_tests/decimal_fast64_t_compile.cpp ;
+compile compile_tests/decimal128_t_compile.cpp ;
+compile compile_tests/decimal_fast128_t_compile.cpp ;
 compile compile_tests/main_header.cpp ;
 compile compile_tests/fenv_compile.cpp ;
 compile compile_tests/format_compile.cpp ;

test/benchmark_libdfp.c

@@ -17,7 +17,7 @@ double float_rand(double min, double max)
     return min + scale * (max - min);
 }
 
-__attribute__ ((__noinline__)) void generate_vector_32(_Decimal32* buffer, size_t buffer_len)
+__attribute__ ((__noinline__)) void generate_vector_32(_decimal32_t* buffer, size_t buffer_len)
 {
     size_t i = 0;
     while (i < buffer_len)
@@ -27,7 +27,7 @@ __attribute__ ((__noinline__)) void generate_vector_32(_Decimal32* buffer, size_
     }
 }
 
-__attribute__ ((__noinline__)) void test_comparisons_32(_Decimal32* data, const char* label)
+__attribute__ ((__noinline__)) void test_comparisons_32(_decimal32_t* data, const char* label)
 {
     struct timespec t1, t2;
     clock_gettime(CLOCK_MONOTONIC, &t1);
@@ -38,8 +38,8 @@ __attribute__ ((__noinline__)) void test_comparisons_32(_Decimal32* data, const
     {
         for (size_t k = 0; k < K - 1; ++k)
         {
-            _Decimal32 val1 = data[k];
-            _Decimal32 val2 = data[k + 1];
+            _decimal32_t val1 = data[k];
+            _decimal32_t val2 = data[k + 1];
 
             s += (size_t)(val1 > val2);
             s += (size_t)(val1 >= val2);
@@ -56,7 +56,7 @@ __attribute__ ((__noinline__)) void test_comparisons_32(_Decimal32* data, const
     printf("Comparisons    <%-10s >: %-10" PRIu64 " us (s=%zu)\n", label, elapsed_time_us, s);
 }
 
-__attribute__ ((__noinline__)) void generate_vector_64(_Decimal64* buffer, size_t buffer_len)
+__attribute__ ((__noinline__)) void generate_vector_64(_decimal64_t* buffer, size_t buffer_len)
 {
     size_t i = 0;
     while (i < buffer_len)
@@ -66,7 +66,7 @@ __attribute__ ((__noinline__)) void generate_vector_64(_Decimal64* buffer, size_
     }
 }
 
-__attribute__ ((__noinline__)) void test_comparisons_64(_Decimal64* data, const char* label)
+__attribute__ ((__noinline__)) void test_comparisons_64(_decimal64_t* data, const char* label)
 {
     struct timespec t1, t2;
     clock_gettime(CLOCK_MONOTONIC, &t1);
@@ -77,8 +77,8 @@ __attribute__ ((__noinline__)) void test_comparisons_64(_Decimal64* data, const
     {
         for (size_t k = 0; k < K - 1; ++k)
         {
-            _Decimal64 val1 = data[k];
-            _Decimal64 val2 = data[k + 1];
+            _decimal64_t val1 = data[k];
+            _decimal64_t val2 = data[k + 1];
 
             s += (size_t)(val1 > val2);
             s += (size_t)(val1 >= val2);
@@ -95,7 +95,7 @@ __attribute__ ((__noinline__)) void test_comparisons_64(_Decimal64* data, const
     printf("Comparisons    <%-10s >: %-10" PRIu64 " us (s=%zu)\n", label, elapsed_time_us, s);
 }
 
-__attribute__ ((__noinline__)) void generate_vector_128(_Decimal128* buffer, size_t buffer_len)
+__attribute__ ((__noinline__)) void generate_vector_128(_decimal128_t* buffer, size_t buffer_len)
 {
     size_t i = 0;
     while (i < buffer_len)
@@ -105,7 +105,7 @@ __attribute__ ((__noinline__)) void generate_vector_128(_Decimal128* buffer, siz
     }
 }
 
-__attribute__ ((__noinline__)) void test_comparisons_128(_Decimal128* data, const char* label)
+__attribute__ ((__noinline__)) void test_comparisons_128(_decimal128_t* data, const char* label)
 {
     struct timespec t1, t2;
     clock_gettime(CLOCK_MONOTONIC, &t1);
@@ -116,8 +116,8 @@ __attribute__ ((__noinline__)) void test_comparisons_128(_Decimal128* data, cons
     {
         for (size_t k = 0; k < K - 1; ++k)
         {
-            _Decimal128 val1 = data[k];
-            _Decimal128 val2 = data[k + 1];
+            _decimal128_t val1 = data[k];
+            _decimal128_t val2 = data[k + 1];
 
             s += (size_t)(val1 > val2);
             s += (size_t)(val1 >= val2);
@@ -134,28 +134,28 @@ __attribute__ ((__noinline__)) void test_comparisons_128(_Decimal128* data, cons
     printf("Comparisons    <%-10s>: %-10" PRIu64 " us (s=%zu)\n", label, elapsed_time_us, s);
 }
 
-typedef _Decimal32 (*operation_32)(_Decimal32, _Decimal32);
+typedef _decimal32_t (*operation_32)(_decimal32_t, _decimal32_t);
 
-__attribute__ ((__noinline__)) _Decimal32 add_32(_Decimal32 a, _Decimal32 b)
+__attribute__ ((__noinline__)) _decimal32_t add_32(_decimal32_t a, _decimal32_t b)
 {
     return a + b;
 }
-__attribute__ ((__noinline__)) _Decimal32 sub_32(_Decimal32 a, _Decimal32 b)
+__attribute__ ((__noinline__)) _decimal32_t sub_32(_decimal32_t a, _decimal32_t b)
 {
     return a - b;
 }
 
-__attribute__ ((__noinline__)) _Decimal32 mul_32(_Decimal32 a, _Decimal32 b)
+__attribute__ ((__noinline__)) _decimal32_t mul_32(_decimal32_t a, _decimal32_t b)
 {
     return a * b;
 }
 
-__attribute__ ((__noinline__)) _Decimal32 div_32(_Decimal32 a, _Decimal32 b)
+__attribute__ ((__noinline__)) _decimal32_t div_32(_decimal32_t a, _decimal32_t b)
 {
     return a / b;
 }
 
-__attribute__ ((__noinline__)) void test_two_element_operation_32(_Decimal32* data, operation_32 op, const char* label, const char* op_label)
+__attribute__ ((__noinline__)) void test_two_element_operation_32(_decimal32_t* data, operation_32 op, const char* label, const char* op_label)
 {
     struct timespec t1, t2;
     clock_gettime(CLOCK_MONOTONIC, &t1);
@@ -166,8 +166,8 @@ __attribute__ ((__noinline__)) void test_two_element_operation_32(_Decimal32* da
     {
         for (size_t k = 0; k < K - 1; ++k)
         {
-            _Decimal32 val1 = data[k];
-            _Decimal32 val2 = data[k + 1];
+            _decimal32_t val1 = data[k];
+            _decimal32_t val2 = data[k + 1];
 
             s += (size_t)op(val1, val2);
         }
@@ -179,29 +179,29 @@ __attribute__ ((__noinline__)) void test_two_element_operation_32(_Decimal32* da
     printf("%-15s<%-10s >: %-10" PRIu64 " us (s=%zu)\n", op_label, label, elapsed_time_us, s);
 }
 
-typedef _Decimal64 (*operation_64)(_Decimal64, _Decimal64);
+typedef _decimal64_t (*operation_64)(_decimal64_t, _decimal64_t);
 
-__attribute__ ((__noinline__)) _Decimal64 add_64(_Decimal64 a, _Decimal64 b)
+__attribute__ ((__noinline__)) _decimal64_t add_64(_decimal64_t a, _decimal64_t b)
 {
     return a + b;
 }
 
-__attribute__ ((__noinline__)) _Decimal64 sub_64(_Decimal64 a, _Decimal64 b)
+__attribute__ ((__noinline__)) _decimal64_t sub_64(_decimal64_t a, _decimal64_t b)
 {
     return a - b;
 }
 
-__attribute__ ((__noinline__)) _Decimal64 mul_64(_Decimal64 a, _Decimal64 b)
+__attribute__ ((__noinline__)) _decimal64_t mul_64(_decimal64_t a, _decimal64_t b)
 {
     return a * b;
 }
 
-__attribute__ ((__noinline__)) _Decimal64 div_64(_Decimal64 a, _Decimal64 b)
+__attribute__ ((__noinline__)) _decimal64_t div_64(_decimal64_t a, _decimal64_t b)
 {
     return a / b;
 }
 
-__attribute__ ((__noinline__)) void test_two_element_operation_64(_Decimal64* data, operation_64 op, const char* label, const char* op_label)
+__attribute__ ((__noinline__)) void test_two_element_operation_64(_decimal64_t* data, operation_64 op, const char* label, const char* op_label)
 {
     struct timespec t1, t2;
     clock_gettime(CLOCK_MONOTONIC, &t1);
@@ -212,8 +212,8 @@ __attribute__ ((__noinline__)) void test_two_element_operation_64(_Decimal64* da
     {
         for (size_t k = 0; k < K - 1; ++k)
         {
-            _Decimal64 val1 = data[k];
-            _Decimal64 val2 = data[k + 1];
+            _decimal64_t val1 = data[k];
+            _decimal64_t val2 = data[k + 1];
 
             s += (size_t)op(val1, val2);
         }
@@ -225,29 +225,29 @@ __attribute__ ((__noinline__)) void test_two_element_operation_64(_Decimal64* da
     printf("%-15s<%-10s >: %-10" PRIu64 " us (s=%zu)\n", op_label, label, elapsed_time_us, s);
 }
 
-typedef _Decimal128 (*operation_128)(_Decimal128, _Decimal128);
+typedef _decimal128_t (*operation_128)(_decimal128_t, _decimal128_t);
 
-__attribute__ ((__noinline__)) _Decimal128 add_128(_Decimal128 a, _Decimal128 b)
+__attribute__ ((__noinline__)) _decimal128_t add_128(_decimal128_t a, _decimal128_t b)
 {
     return a + b;
 }
 
-__attribute__ ((__noinline__)) _Decimal128 sub_128(_Decimal128 a, _Decimal128 b)
+__attribute__ ((__noinline__)) _decimal128_t sub_128(_decimal128_t a, _decimal128_t b)
 {
     return a - b;
 }
 
-__attribute__ ((__noinline__)) _Decimal128 mul_128(_Decimal128 a, _Decimal128 b)
+__attribute__ ((__noinline__)) _decimal128_t mul_128(_decimal128_t a, _decimal128_t b)
 {
     return a * b;
 }
 
-__attribute__ ((__noinline__)) _Decimal128 div_128(_Decimal128 a, _Decimal128 b)
+__attribute__ ((__noinline__)) _decimal128_t div_128(_decimal128_t a, _decimal128_t b)
 {
     return a / b;
 }
 
-__attribute__ ((__noinline__)) void test_two_element_operation_128(_Decimal128* data, operation_128 op, const char* label, const char* op_label)
+__attribute__ ((__noinline__)) void test_two_element_operation_128(_decimal128_t* data, operation_128 op, const char* label, const char* op_label)
 {
     struct timespec t1, t2;
     clock_gettime(CLOCK_MONOTONIC, &t1);
@@ -258,8 +258,8 @@ __attribute__ ((__noinline__)) void test_two_element_operation_128(_Decimal128*
     {
         for (size_t k = 0; k < K - 1; ++k)
         {
-            _Decimal128 val1 = data[k];
-            _Decimal128 val2 = data[k + 1];
+            _decimal128_t val1 = data[k];
+            _decimal128_t val2 = data[k + 1];
 
             s += (size_t)op(val1, val2);
         }
@@ -276,9 +276,9 @@ int main()
     // One time init of random number generator
     srand(time(NULL));
 
-    _Decimal32* d32_array = malloc(K * sizeof(_Decimal32));
-    _Decimal64* d64_array = malloc(K * sizeof(_Decimal64));
-    _Decimal128* d128_array = malloc(K * sizeof(_Decimal128));
+    _decimal32_t* d32_array = malloc(K * sizeof(_decimal32_t));
+    _decimal64_t* d64_array = malloc(K * sizeof(_decimal64_t));
+    _decimal128_t* d128_array = malloc(K * sizeof(_decimal128_t));
 
     if (d32_array == NULL || d64_array == NULL || d128_array == NULL)
     {
@@ -288,37 +288,37 @@ int main()
     printf("===== Comparisons =====\n");
 
     generate_vector_32(d32_array, K);
-    test_comparisons_32(d32_array, "_Decimal32");
+    test_comparisons_32(d32_array, "_decimal32_t");
 
     generate_vector_64(d64_array, K);
-    test_comparisons_64(d64_array, "_Decimal64");
+    test_comparisons_64(d64_array, "_decimal64_t");
 
     generate_vector_128(d128_array, K);
-    test_comparisons_128(d128_array, "_Decimal128");
+    test_comparisons_128(d128_array, "_decimal128_t");
 
     printf("\n===== Addition =====\n");
 
-    test_two_element_operation_32(d32_array, add_32, "_Decimal32", "Addition");
-    test_two_element_operation_64(d64_array, add_64, "_Decimal64", "Addition");
-    test_two_element_operation_128(d128_array, add_128, "_Decimal128", "Addition");
+    test_two_element_operation_32(d32_array, add_32, "_decimal32_t", "Addition");
+    test_two_element_operation_64(d64_array, add_64, "_decimal64_t", "Addition");
+    test_two_element_operation_128(d128_array, add_128, "_decimal128_t", "Addition");
 
     printf("\n===== Subtraction =====\n");
 
-    test_two_element_operation_32(d32_array, sub_32, "_Decimal32", "Subtraction");
-    test_two_element_operation_64(d64_array, sub_64, "_Decimal64", "Subtraction");
-    test_two_element_operation_128(d128_array, sub_128, "_Decimal128", "Subtraction");
+    test_two_element_operation_32(d32_array, sub_32, "_decimal32_t", "Subtraction");
+    test_two_element_operation_64(d64_array, sub_64, "_decimal64_t", "Subtraction");
+    test_two_element_operation_128(d128_array, sub_128, "_decimal128_t", "Subtraction");
 
     printf("\n===== Multiplication =====\n");
 
-    test_two_element_operation_32(d32_array, mul_32, "_Decimal32", "Multiplication");
-    test_two_element_operation_64(d64_array, mul_64, "_Decimal64", "Multiplication");
-    test_two_element_operation_128(d128_array, mul_128, "_Decimal128", "Multiplication");
+    test_two_element_operation_32(d32_array, mul_32, "_decimal32_t", "Multiplication");
+    test_two_element_operation_64(d64_array, mul_64, "_decimal64_t", "Multiplication");
+    test_two_element_operation_128(d128_array, mul_128, "_decimal128_t", "Multiplication");
 
     printf("\n===== Division =====\n");
 
-    test_two_element_operation_32(d32_array, div_32, "_Decimal32", "Division");
-    test_two_element_operation_64(d64_array, div_64, "_Decimal64", "Division");
-    test_two_element_operation_128(d128_array, div_128, "_Decimal128", "Division");
+    test_two_element_operation_32(d32_array, div_32, "_decimal32_t", "Division");
+    test_two_element_operation_64(d64_array, div_64, "_decimal64_t", "Division");
+    test_two_element_operation_128(d128_array, div_128, "_decimal128_t", "Division");
 
     free(d32_array);
     free(d64_array);