More bulk repairs

Author: mborland

include/boost/decimal/decimal128.hpp

@@ -543,7 +543,7 @@ BOOST_DECIMAL_EXPORT class decimal128_t final
     friend constexpr auto fmad128(decimal128_t x, decimal128_t y, decimal128_t z) noexcept -> decimal128_t;
 };
 
-[[deprecated("Use re-named type decimal128_t instead of decimal128")]] BOOST_DECIMAL_EXPORT using decimal128 = decimal128_t;
+BOOST_DECIMAL_EXPORT using decimal128 [[deprecated("Use re-named type decimal128_t instead of decimal128")]] = decimal128_t;
 
 #if !defined(BOOST_DECIMAL_DISABLE_IOSTREAM)
 inline std::string bit_string(decimal128_t rhs) noexcept

include/boost/decimal/decimal128_fast.hpp

@@ -40,7 +40,6 @@ BOOST_DECIMAL_CONSTEXPR_VARIABLE auto d128_fast_snan_high_bits = UINT64_MAX;
 
 } // namespace detail
 
-[[deprecated("Use re-named type decimal_fast128_t instead of decimal_fast128_t")]]
 BOOST_DECIMAL_EXPORT class decimal_fast128_t final
 {
 public:
@@ -370,7 +369,7 @@ BOOST_DECIMAL_EXPORT class decimal_fast128_t final
     friend constexpr auto quantized128f(const decimal_fast128_t& lhs, const decimal_fast128_t& rhs) noexcept -> decimal_fast128_t;
 };
 
-[[deprecated("Use re-named type decimal_fast128_t instead of decimal128_fast")]] using decimal128_fast = decimal_fast128_t;
+BOOST_DECIMAL_EXPORT using decimal128_fast [[deprecated("Use re-named type decimal_fast128_t instead of decimal128_fast")]] = decimal_fast128_t;
 
 #ifdef BOOST_DECIMAL_HAS_CONCEPTS
 template <BOOST_DECIMAL_UNSIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>

include/boost/decimal/decimal32.hpp

@@ -563,7 +563,7 @@ BOOST_DECIMAL_EXPORT class decimal32_t final // NOLINT(cppcoreguidelines-special
     constexpr auto edit_sign(bool sign) noexcept -> void;
 };
 
-[[deprecated("Use the renamed decimal32_t instead of decimal32")]] BOOST_DECIMAL_EXPORT using decimal32 = decimal32_t;
+BOOST_DECIMAL_EXPORT using decimal32 [[deprecated("Use the renamed decimal32_t instead of decimal32")]] = decimal32_t;
 
 #if defined(__GNUC__) && __GNUC__ >= 8
 #  pragma GCC diagnostic pop

include/boost/decimal/decimal32_fast.hpp

@@ -374,7 +374,7 @@ BOOST_DECIMAL_EXPORT class decimal_fast32_t final
     friend constexpr auto quantized32f(decimal_fast32_t lhs, decimal_fast32_t rhs) noexcept -> decimal_fast32_t;
 };
 
-[[deprecated("Use re-named type decimal_fast32_t instead of decimal_fast32_t")]] BOOST_DECIMAL_EXPORT using decimal32_fast = decimal_fast32_t;
+BOOST_DECIMAL_EXPORT using decimal32_fast [[deprecated("Use re-named type decimal_fast32_t instead of decimal_fast32_t")]] = decimal_fast32_t;
 
 template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>
 constexpr decimal_fast32_t::decimal_fast32_t(T1 coeff, T2 exp, bool sign) noexcept

include/boost/decimal/decimal64.hpp

@@ -551,7 +551,7 @@ BOOST_DECIMAL_EXPORT class decimal64_t final
     friend constexpr auto scalblnd64(decimal64_t num, long exp) noexcept -> decimal64_t;
 };
 
-[[deprecated("Use re-named type decimal64_t instead of decimal64")]] BOOST_DECIMAL_EXPORT using decimal64 = decimal64_t;
+BOOST_DECIMAL_EXPORT using decimal64 [[deprecated("Use re-named type decimal64_t instead of decimal64")]] = decimal64_t;
 
 #if defined(__GNUC__) && __GNUC__ >= 8
 #  pragma GCC diagnostic pop

include/boost/decimal/decimal64_fast.hpp

@@ -382,7 +382,7 @@ BOOST_DECIMAL_EXPORT class decimal_fast64_t final
     friend constexpr auto scalblnd64f(decimal_fast64_t num, long exp) noexcept -> decimal_fast64_t;
 };
 
-[[deprecated("Use re-named type decimal_fast64_t instead of decimal64_fast")]] BOOST_DECIMAL_EXPORT using decimal64_fast = decimal_fast64_t;
+BOOST_DECIMAL_EXPORT using decimal64_fast [[deprecated("Use re-named type decimal_fast64_t instead of decimal64_fast")]] = decimal_fast64_t;
 
 #ifdef BOOST_DECIMAL_HAS_CONCEPTS
 template <BOOST_DECIMAL_UNSIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>

include/boost/decimal/decimal_fast128_t.hpp

@@ -5,6 +5,6 @@
 #ifndef BOOST_DECIMAL_DECIMAL_FAST128_T_HPP
 #define BOOST_DECIMAL_DECIMAL_FAST128_T_HPP
 
-#include <boost/decimal/decimal64_fast.hpp>
+#include <boost/decimal/decimal128_fast.hpp>
 
 #endif // BOOST_DECIMAL_DECIMAL_FAST128_T_HPP

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_t_t* 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_t_t* buffer, s
     }
 }
 
-__attribute__ ((__noinline__)) void test_comparisons_32(_decimal32_t_t* 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_t_t* data, co
     {
         for (size_t k = 0; k < K - 1; ++k)
         {
-            _decimal32_t_t val1 = data[k];
-            _decimal32_t_t 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_t_t* data, co
     printf("Comparisons    <%-10s >: %-10" PRIu64 " us (s=%zu)\n", label, elapsed_time_us, s);
 }
 
-__attribute__ ((__noinline__)) void generate_vector_64(_decimal64_t_t* 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_t_t* buffer, s
     }
 }
 
-__attribute__ ((__noinline__)) void test_comparisons_64(_decimal64_t_t* 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_t_t* data, co
     {
         for (size_t k = 0; k < K - 1; ++k)
         {
-            _decimal64_t_t val1 = data[k];
-            _decimal64_t_t 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_t_t* data, co
     printf("Comparisons    <%-10s >: %-10" PRIu64 " us (s=%zu)\n", label, elapsed_time_us, s);
 }
 
-__attribute__ ((__noinline__)) void generate_vector_128(_decimal128_t_t* 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_t_t* buffer,
     }
 }
 
-__attribute__ ((__noinline__)) void test_comparisons_128(_decimal128_t_t* 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_t_t* data,
     {
         for (size_t k = 0; k < K - 1; ++k)
         {
-            _decimal128_t_t val1 = data[k];
-            _decimal128_t_t 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_t_t* data,
     printf("Comparisons    <%-10s>: %-10" PRIu64 " us (s=%zu)\n", label, elapsed_time_us, s);
 }
 
-typedef _decimal32_t_t (*operation_32)(_decimal32_t_t, _decimal32_t_t);
+typedef _decimal32_t (*operation_32)(_decimal32_t, _decimal32_t);
 
-__attribute__ ((__noinline__)) _decimal32_t_t add_32(_decimal32_t_t a, _decimal32_t_t b)
+__attribute__ ((__noinline__)) _decimal32_t add_32(_decimal32_t a, _decimal32_t b)
 {
     return a + b;
 }
-__attribute__ ((__noinline__)) _decimal32_t_t sub_32(_decimal32_t_t a, _decimal32_t_t b)
+__attribute__ ((__noinline__)) _decimal32_t sub_32(_decimal32_t a, _decimal32_t b)
 {
     return a - b;
 }
 
-__attribute__ ((__noinline__)) _decimal32_t_t mul_32(_decimal32_t_t a, _decimal32_t_t b)
+__attribute__ ((__noinline__)) _decimal32_t mul_32(_decimal32_t a, _decimal32_t b)
 {
     return a * b;
 }
 
-__attribute__ ((__noinline__)) _decimal32_t_t div_32(_decimal32_t_t a, _decimal32_t_t 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_t_t* 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_t_t
     {
         for (size_t k = 0; k < K - 1; ++k)
         {
-            _decimal32_t_t val1 = data[k];
-            _decimal32_t_t 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_t_t
     printf("%-15s<%-10s >: %-10" PRIu64 " us (s=%zu)\n", op_label, label, elapsed_time_us, s);
 }
 
-typedef _decimal64_t_t (*operation_64)(_decimal64_t_t, _decimal64_t_t);
+typedef _decimal64_t (*operation_64)(_decimal64_t, _decimal64_t);
 
-__attribute__ ((__noinline__)) _decimal64_t_t add_64(_decimal64_t_t a, _decimal64_t_t b)
+__attribute__ ((__noinline__)) _decimal64_t add_64(_decimal64_t a, _decimal64_t b)
 {
     return a + b;
 }
 
-__attribute__ ((__noinline__)) _decimal64_t_t sub_64(_decimal64_t_t a, _decimal64_t_t b)
+__attribute__ ((__noinline__)) _decimal64_t sub_64(_decimal64_t a, _decimal64_t b)
 {
     return a - b;
 }
 
-__attribute__ ((__noinline__)) _decimal64_t_t mul_64(_decimal64_t_t a, _decimal64_t_t b)
+__attribute__ ((__noinline__)) _decimal64_t mul_64(_decimal64_t a, _decimal64_t b)
 {
     return a * b;
 }
 
-__attribute__ ((__noinline__)) _decimal64_t_t div_64(_decimal64_t_t a, _decimal64_t_t 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_t_t* 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_t_t
     {
         for (size_t k = 0; k < K - 1; ++k)
         {
-            _decimal64_t_t val1 = data[k];
-            _decimal64_t_t 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_t_t
     printf("%-15s<%-10s >: %-10" PRIu64 " us (s=%zu)\n", op_label, label, elapsed_time_us, s);
 }
 
-typedef _decimal128_t_t (*operation_128)(_decimal128_t_t, _decimal128_t_t);
+typedef _decimal128_t (*operation_128)(_decimal128_t, _decimal128_t);
 
-__attribute__ ((__noinline__)) _decimal128_t_t add_128(_decimal128_t_t a, _decimal128_t_t b)
+__attribute__ ((__noinline__)) _decimal128_t add_128(_decimal128_t a, _decimal128_t b)
 {
     return a + b;
 }
 
-__attribute__ ((__noinline__)) _decimal128_t_t sub_128(_decimal128_t_t a, _decimal128_t_t b)
+__attribute__ ((__noinline__)) _decimal128_t sub_128(_decimal128_t a, _decimal128_t b)
 {
     return a - b;
 }
 
-__attribute__ ((__noinline__)) _decimal128_t_t mul_128(_decimal128_t_t a, _decimal128_t_t b)
+__attribute__ ((__noinline__)) _decimal128_t mul_128(_decimal128_t a, _decimal128_t b)
 {
     return a * b;
 }
 
-__attribute__ ((__noinline__)) _decimal128_t_t div_128(_decimal128_t_t a, _decimal128_t_t 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_t_t* 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_t
     {
         for (size_t k = 0; k < K - 1; ++k)
         {
-            _decimal128_t_t val1 = data[k];
-            _decimal128_t_t 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_t_t* d32_array = malloc(K * sizeof(_decimal32_t_t));
-    _decimal64_t_t* d64_array = malloc(K * sizeof(_decimal64_t_t));
-    _decimal128_t_t* d128_array = malloc(K * sizeof(_decimal128_t_t));
+    _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_t_t");
+    test_comparisons_32(d32_array, "_decimal32_t");
 
     generate_vector_64(d64_array, K);
-    test_comparisons_64(d64_array, "_decimal64_t_t");
+    test_comparisons_64(d64_array, "_decimal64_t");
 
     generate_vector_128(d128_array, K);
-    test_comparisons_128(d128_array, "_decimal128_t_t");
+    test_comparisons_128(d128_array, "_decimal128_t");
 
     printf("\n===== Addition =====\n");
 
-    test_two_element_operation_32(d32_array, add_32, "_decimal32_t_t", "Addition");
-    test_two_element_operation_64(d64_array, add_64, "_decimal64_t_t", "Addition");
-    test_two_element_operation_128(d128_array, add_128, "_decimal128_t_t", "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_t_t", "Subtraction");
-    test_two_element_operation_64(d64_array, sub_64, "_decimal64_t_t", "Subtraction");
-    test_two_element_operation_128(d128_array, sub_128, "_decimal128_t_t", "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_t_t", "Multiplication");
-    test_two_element_operation_64(d64_array, mul_64, "_decimal64_t_t", "Multiplication");
-    test_two_element_operation_128(d128_array, mul_128, "_decimal128_t_t", "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_t_t", "Division");
-    test_two_element_operation_64(d64_array, div_64, "_decimal64_t_t", "Division");
-    test_two_element_operation_128(d128_array, div_128, "_decimal128_t_t", "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);