Drop the _t from the type names

.github/workflows/amalgamate.yml

@@ -66,7 +66,7 @@ jobs:
                   return 2;
               }
 
-              if (saturating_add(a, b) != (std::numeric_limits<uint128_t>::max)())
+              if (saturating_add(a, b) != (std::numeric_limits<uint128>::max)())
               {
                   return 3;
               }

.github/workflows/ci.yml

@@ -997,7 +997,7 @@ jobs:
           #include <iostream>
           int main() {
               using namespace boost::int128;
-              uint128_t d{456};
+              uint128 d{456};
               std::cout << "Value: " << d << "\n";
               return 0;
           }
@@ -1075,7 +1075,7 @@ jobs:
           #include <iostream>
           int main() {
               using namespace boost::int128;
-              uint128_t d{42};
+              uint128 d{42};
               std::cout << "Value: " << d << "\n";
               return 0;
           }
@@ -1145,7 +1145,7 @@ jobs:
           #include <iostream>
           int main() {
               using namespace boost::int128;
-              uint128_t d{123};
+              uint128 d{123};
               std::cout << "Value: " << d << "\n";
               return 0;
           }

README.md

@@ -57,8 +57,8 @@ Int128 provides 2 types:
 namespace boost {
 namespace int128 {
 
-struct uint128_t;
-struct int128_t;
+struct uint128;
+struct int128;
 
 } //namespace int128
 } //namespace boost

doc/modules/ROOT/nav.adoc

@@ -47,24 +47,24 @@
 *** xref:api_reference.adoc#api_macro_configuration[Configuration]
 ** xref:api_reference.adoc#api_headers[Headers]
 * xref:file_structure.adoc[]
-* xref:uint128_t.adoc[]
-** xref:uint128_t.adoc#u128_alignment[Alignment]
-** xref:uint128_t.adoc#u128_operator_behavior[Operator Behavior]
-** xref:uint128_t.adoc#u128_constructors[Constructors]
-** xref:uint128_t.adoc#u128_conversions[Conversion Operators]
-** xref:uint128_t.adoc#u128_comparison_operators[Comparison Operators]
-** xref:uint128_t.adoc#u128_bitwise_operators[Bitwise Operators]
-** xref:uint128_t.adoc#u128_math_operators[Mathematical Operators]
-** xref:uint128_t.adoc#u128_limits[`<limits>` Support and Values]
-* xref:int128_t.adoc[]
-** xref:int128_t.adoc#i128_alignment[Alignment]
-** xref:int128_t.adoc#i128_operator_behavior[Operator Behavior]
-** xref:int128_t.adoc#i128_constructors[Constructors]
-** xref:int128_t.adoc#i128_conversions[Conversion Operators]
-** xref:int128_t.adoc#i128_comparison_operators[Comparison Operators]
-** xref:int128_t.adoc#i128_bitwise_operators[Bitwise Operators]
-** xref:int128_t.adoc#i128_math_operators[Mathematical Operators]
-** xref:int128_t.adoc#i128_limits[`<limits>` Support and Values]
+* xref:uint128.adoc[]
+** xref:uint128.adoc#u128_alignment[Alignment]
+** xref:uint128.adoc#u128_operator_behavior[Operator Behavior]
+** xref:uint128.adoc#u128_constructors[Constructors]
+** xref:uint128.adoc#u128_conversions[Conversion Operators]
+** xref:uint128.adoc#u128_comparison_operators[Comparison Operators]
+** xref:uint128.adoc#u128_bitwise_operators[Bitwise Operators]
+** xref:uint128.adoc#u128_math_operators[Mathematical Operators]
+** xref:uint128.adoc#u128_limits[`<limits>` Support and Values]
+* xref:int128.adoc[]
+** xref:int128.adoc#i128_alignment[Alignment]
+** xref:int128.adoc#i128_operator_behavior[Operator Behavior]
+** xref:int128.adoc#i128_constructors[Constructors]
+** xref:int128.adoc#i128_conversions[Conversion Operators]
+** xref:int128.adoc#i128_comparison_operators[Comparison Operators]
+** xref:int128.adoc#i128_bitwise_operators[Bitwise Operators]
+** xref:int128.adoc#i128_math_operators[Mathematical Operators]
+** xref:int128.adoc#i128_limits[`<limits>` Support and Values]
 * xref:mixed_type_ops.adoc[]
 * xref:literals.adoc[]
 * xref:bit.adoc[`<bit>` (Bitwise ops)]

doc/modules/ROOT/pages/api_reference.adoc

@@ -33,10 +33,10 @@ https://www.boost.org/LICENSE_1_0.txt
 |===
 | Type | Description
 
-| xref:uint128_t.adoc[`uint128_t`]
+| xref:uint128.adoc[`uint128`]
 | Unsigned 128-bit integer
 
-| xref:int128_t.adoc[`int128_t`]
+| xref:int128.adoc[`int128`]
 | Signed 128-bit integer
 |===
 
@@ -67,23 +67,23 @@ https://www.boost.org/LICENSE_1_0.txt
 |===
 | Structure | Description
 
-| https://en.cppreference.com/w/cpp/types/numeric_limits[`std::numeric_limits<uint128_t>`]
-| Numeric limits specialization for `uint128_t`
+| https://en.cppreference.com/w/cpp/types/numeric_limits[`std::numeric_limits<uint128>`]
+| Numeric limits specialization for `uint128`
 
-| https://en.cppreference.com/w/cpp/types/numeric_limits[`std::numeric_limits<int128_t>`]
-| Numeric limits specialization for `int128_t`
+| https://en.cppreference.com/w/cpp/types/numeric_limits[`std::numeric_limits<int128>`]
+| Numeric limits specialization for `int128`
 
-| xref:hash.adoc[`std::hash<uint128_t>`]
-| Hash specialization for `uint128_t`
+| xref:hash.adoc[`std::hash<uint128>`]
+| Hash specialization for `uint128`
 
-| xref:hash.adoc[`std::hash<int128_t>`]
-| Hash specialization for `int128_t`
+| xref:hash.adoc[`std::hash<int128>`]
+| Hash specialization for `int128`
 
 | xref:cstdlib.adoc#div_structs[`u128div_t`]
-| Result type for `div(uint128_t, uint128_t)`
+| Result type for `div(uint128, uint128)`
 
 | xref:cstdlib.adoc#div_structs[`i128div_t`]
-| Result type for `div(int128_t, int128_t)`
+| Result type for `div(int128, int128)`
 
 | xref:numeric.adoc#div_result[`div_result<T>`]
 | Result type for the `div_rem_*` functions
@@ -159,7 +159,7 @@ Listed by analogous STL header.
 |===
 | Function | Description
 
-| xref:int128_t.adoc#i128_abs[`abs`]
+| xref:int128.adoc#i128_abs[`abs`]
 | Absolute value
 |===
 
@@ -181,11 +181,11 @@ Listed by analogous STL header.
 |===
 | Specialization | Description
 
-| xref:hash.adoc[`std::hash<uint128_t>`]
-| Enables `uint128_t` as a key in unordered associative containers
+| xref:hash.adoc[`std::hash<uint128>`]
+| Enables `uint128` as a key in unordered associative containers
 
-| xref:hash.adoc[`std::hash<int128_t>`]
-| Enables `int128_t` as a key in unordered associative containers
+| xref:hash.adoc[`std::hash<int128>`]
+| Enables `int128` as a key in unordered associative containers
 |===
 
 [#api_formatting]
@@ -384,13 +384,13 @@ Listed by analogous STL header.
 | Macro | Description
 
 | `BOOST_INT128_UINT128_MAX`
-| Maximum value for `uint128_t`
+| Maximum value for `uint128`
 
 | `BOOST_INT128_INT128_MAX`
-| Maximum value for `int128_t`
+| Maximum value for `int128`
 
 | `BOOST_INT128_INT128_MIN`
-| Minimum value for `int128_t`
+| Minimum value for `int128`
 |===
 
 === Literals
@@ -488,19 +488,19 @@ Listed by analogous STL header.
 | Formatting integration for pass:[C++20] `<format>`
 
 | xref:hash.adoc[`<boost/int128/hash.hpp>`]
-| `std::hash` specializations for `int128_t` and `uint128_t`
+| `std::hash` specializations for `int128` and `uint128`
 
 | `<boost/int128/int128.hpp>`
-| The xref:uint128_t.adoc[`uint128_t`] and xref:int128_t.adoc[`int128_t`] types
+| The xref:uint128.adoc[`uint128`] and xref:int128.adoc[`int128`] types
 
 | xref:stream.adoc[`<boost/int128/iostream.hpp>`]
-| Iostream overloads for `int128_t` and `uint128_t`
+| Iostream overloads for `int128` and `uint128`
 
 | `<boost/int128/limits.hpp>`
-| Overloads for `std::numeric_limits` for `int128_t` and `uint128_t`
+| Overloads for `std::numeric_limits` for `int128` and `uint128`
 
 | xref:literals.adoc[`<boost/int128/literals.hpp>`]
-| User-defined literals for `int128_t` and `uint128_t`
+| User-defined literals for `int128` and `uint128`
 
 | xref:numeric.adoc[`<boost/int128/numeric.hpp>`]
 | Numeric algorithms (gcd, lcm, midpoint, integer division)

doc/modules/ROOT/pages/bit.adoc

@@ -13,8 +13,8 @@ https://www.boost.org/LICENSE_1_0.txt
 #include <boost/int128/bit.hpp>
 ----
 
-The following are functions analogous to those found in pass:[C++20] https://en.cppreference.com/w/cpp/header/bit[<bit>] header, but for `boost::int128::uint128_t`.
-None of these functions apply to signed integral types, and thus none have overloads for `boost::int128::int128_t`.
+The following are functions analogous to those found in pass:[C++20] https://en.cppreference.com/w/cpp/header/bit[<bit>] header, but for `boost::int128::uint128`.
+None of these functions apply to signed integral types, and thus none have overloads for `boost::int128::int128`.
 All of these functions are available using pass:[C++14] like the rest of the library.
 
 [#has_single_bit]
@@ -28,7 +28,7 @@ Returns `true` if `x` is a power of two; otherwise `false`
 namespace boost {
 namespace int128 {
 
-BOOST_INT128_HOST_DEVICE constexpr bool has_single_bit(uint128_t x) noexcept;
+BOOST_INT128_HOST_DEVICE constexpr bool has_single_bit(uint128 x) noexcept;
 
 } // namespace int128
 } // namespace boost
@@ -44,7 +44,7 @@ Returns the number of consecutive `0` bits in the value `x`, starting from the m
 namespace boost {
 namespace int128 {
 
-BOOST_INT128_HOST_DEVICE constexpr int countl_zero(uint128_t x) noexcept;
+BOOST_INT128_HOST_DEVICE constexpr int countl_zero(uint128 x) noexcept;
 
 } // namespace int128
 } // namespace boost
@@ -60,7 +60,7 @@ Returns the number of consecutive `1` bits in the value `x`, starting from the m
 namespace boost {
 namespace int128 {
 
-BOOST_INT128_HOST_DEVICE constexpr int countl_one(uint128_t x) noexcept;
+BOOST_INT128_HOST_DEVICE constexpr int countl_one(uint128 x) noexcept;
 
 } // namespace int128
 } // namespace boost
@@ -77,7 +77,7 @@ If `x` is zero, returns 0
 namespace boost {
 namespace int128 {
 
-BOOST_INT128_HOST_DEVICE constexpr int bit_width(uint128_t x) noexcept;
+BOOST_INT128_HOST_DEVICE constexpr int bit_width(uint128 x) noexcept;
 
 } // namespace int128
 } // namespace boost
@@ -93,7 +93,7 @@ Returns the smallest integral power of two that is not smaller than `x`.
 namespace boost {
 namespace int128 {
 
-BOOST_INT128_HOST_DEVICE constexpr uint128_t bit_ceil(uint128_t x) noexcept;
+BOOST_INT128_HOST_DEVICE constexpr uint128 bit_ceil(uint128 x) noexcept;
 
 } // namespace int128
 } // namespace boost
@@ -110,7 +110,7 @@ If `x` is 0 then returns 0.
 namespace boost {
 namespace int128 {
 
-BOOST_INT128_HOST_DEVICE constexpr uint128_t bit_floor(uint128_t x) noexcept;
+BOOST_INT128_HOST_DEVICE constexpr uint128 bit_floor(uint128 x) noexcept;
 
 } // namespace int128
 } // namespace boost
@@ -126,7 +126,7 @@ Returns the number of consecutive `0` bits in the value `x`, starting from the l
 namespace boost {
 namespace int128 {
 
-BOOST_INT128_HOST_DEVICE constexpr int countr_zero(uint128_t x) noexcept;
+BOOST_INT128_HOST_DEVICE constexpr int countr_zero(uint128 x) noexcept;
 
 } // namespace int128
 } // namespace boost
@@ -142,7 +142,7 @@ Returns the number of consecutive `1` bits in the value `x`, starting from the l
 namespace boost {
 namespace int128 {
 
-BOOST_INT128_HOST_DEVICE constexpr int countr_one(uint128_t x) noexcept;
+BOOST_INT128_HOST_DEVICE constexpr int countr_one(uint128 x) noexcept;
 
 } // namespace int128
 } // namespace boost
@@ -159,7 +159,7 @@ This operation is also known as a left circular shift.
 namespace boost {
 namespace int128 {
 
-BOOST_INT128_HOST_DEVICE constexpr uint128_t rotl(uint128_t x, int s) noexcept;
+BOOST_INT128_HOST_DEVICE constexpr uint128 rotl(uint128 x, int s) noexcept;
 
 } // namespace int128
 } // namespace boost
@@ -176,7 +176,7 @@ This operation is also known as a right circular shift.
 namespace boost {
 namespace int128 {
 
-BOOST_INT128_HOST_DEVICE constexpr uint128_t rotr(uint128_t x, int s) noexcept;
+BOOST_INT128_HOST_DEVICE constexpr uint128 rotr(uint128 x, int s) noexcept;
 
 } // namespace int128
 } // namespace boost
@@ -192,7 +192,7 @@ Returns the number of `1` bits in `x`.
 namespace boost {
 namespace int128 {
 
-BOOST_INT128_HOST_DEVICE constexpr int popcount(uint128_t x) noexcept;
+BOOST_INT128_HOST_DEVICE constexpr int popcount(uint128 x) noexcept;
 
 } // namespace int128
 } // namespace boost
@@ -208,7 +208,7 @@ Reverses the bytes in the given integer value `x`.
 namespace boost {
 namespace int128 {
 
-BOOST_INT128_HOST_DEVICE constexpr uint128_t byteswap(uint128_t x) noexcept;
+BOOST_INT128_HOST_DEVICE constexpr uint128 byteswap(uint128 x) noexcept;
 
 } // namespace int128
 } // namespace boost

doc/modules/ROOT/pages/charconv.adoc

@@ -47,9 +47,9 @@ struct to_chars_result
 };
 
 
-BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars(char* first, char* last, int128::uint128_t value, int base = 10) noexcept;
+BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars(char* first, char* last, int128::uint128 value, int base = 10) noexcept;
 
-BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars(char* first, char* last, int128::int128_t value, int base = 10) noexcept;
+BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars(char* first, char* last, int128::int128 value, int base = 10) noexcept;
 
 } // namespace charconv
 } // namespace boost
@@ -83,15 +83,15 @@ struct from_chars_result
     constexpr explicit operator bool() const noexcept { return ec == std::errc{}; }
 };
 
-constexpr from_chars_result from_chars(const char* first, const char* last, int128::uint128_t& value, int base = 10) noexcept;
+constexpr from_chars_result from_chars(const char* first, const char* last, int128::uint128& value, int base = 10) noexcept;
 
 // Allows both std::string and std::string_view (when available)
-constexpr from_chars_result from_chars(core::string_view sv, int128::uint128_t& value, int base = 10) noexcept;
+constexpr from_chars_result from_chars(core::string_view sv, int128::uint128& value, int base = 10) noexcept;
 
-constexpr from_chars_result from_chars(const char* first, const char* last, int128::int128_t& value, int base = 10) noexcept;
+constexpr from_chars_result from_chars(const char* first, const char* last, int128::int128& value, int base = 10) noexcept;
 
 // Allows both std::string and std::string_view (when available)
-constexpr from_chars_result from_chars(core::string_view sv, int128::int128_t& value, int base = 10) noexcept;
+constexpr from_chars_result from_chars(core::string_view sv, int128::int128& value, int base = 10) noexcept;
 
 } // namespace charconv
 } // namespace boost

doc/modules/ROOT/pages/comp_to_multiprecision.adoc

@@ -14,6 +14,6 @@ There are several reasons why:
 The module weight of this library will be 5, whereas https://pdimov.github.io/boostdep-report/develop/module-weights.html[Boost.Multiprecision is 25]
 - Fundamentally, the designs of the types are different.
 In Boost.Multiprecision, `int128` and `uint128` are incident to the arbitrary precision integer `cpp_int`, not a specifically designed type.
-In this library both `int128_t` and `uint128_t` are their own classes with individually implemented operators to maximize performance.
+In this library both `int128` and `uint128` are their own classes with individually implemented operators to maximize performance.
 - In Boost.Multiprecision all types are based on a high-level template `number` to allow interoperability with each other.
-Again, both `int128_t` and `uint128_t` are their own classes, and are designed to work with and act like the built-in integer types.
+Again, both `int128` and `uint128` are their own classes, and are designed to work with and act like the built-in integer types.

doc/modules/ROOT/pages/config.adoc

@@ -111,4 +111,4 @@ They are most useful for writing code that has to adapt to what the platform pro
 
 [#host_device]
 - `BOOST_INT128_HOST_DEVICE`: This is defined to `pass:[__host__ __device__]` when compiling for CUDA (`pass:[__CUDACC__]` with `BOOST_INT128_ENABLE_CUDA`), to `SYCL_EXTERNAL` when compiling for SYCL (`BOOST_INT128_ENABLE_SYCL`), and to nothing otherwise.
-The core type operations (constructors, conversion operators, and the comparison, bitwise, arithmetic, and shift operators) and most free functions are annotated with this macro, allowing `int128_t` and `uint128_t` to be used in CUDA and SYCL device code. Host-only integrations that depend on host facilities are not annotated: `std::hash`, the iostream operators, the `std::formatter` / pass:[{fmt}] support, and the `core::string_view` overloads of `from_chars`. Under SYCL the `operator long double` conversion is additionally unavailable because the spir64 device target has no `long double`.
+The core type operations (constructors, conversion operators, and the comparison, bitwise, arithmetic, and shift operators) and most free functions are annotated with this macro, allowing `int128` and `uint128` to be used in CUDA and SYCL device code. Host-only integrations that depend on host facilities are not annotated: `std::hash`, the iostream operators, the `std::formatter` / pass:[{fmt}] support, and the `core::string_view` overloads of `from_chars`. Under SYCL the `operator long double` conversion is additionally unavailable because the spir64 device target has no `long double`.