From 9c0cbae55612166da0dc09a4423bdaa50823e6e7 Mon Sep 17 00:00:00 2001 From: Beman Date: Mon, 23 Feb 2015 07:24:17 -0500 Subject: [PATCH] Revert the default (*_t) types to unaligned, and used *_at to identify the aligned types. See mini-review thread for rationale. --- doc/arithmetic.html | 294 +++++----- doc/buffers.html | 168 +++--- doc/index.html | 8 +- example/endian_example.cpp | 8 +- include/boost/endian/arithmetic.hpp | 184 +++---- include/boost/endian/buffers.hpp | 184 +++---- test/buffer_test.cpp | 134 ++--- test/endian_in_union_test.cpp | 96 ++-- test/endian_operations_test.cpp | 238 ++++----- test/endian_test.cpp | 802 ++++++++++++++-------------- test/loop_time_test.cpp | 24 +- 11 files changed, 1070 insertions(+), 1070 deletions(-) diff --git a/doc/arithmetic.html b/doc/arithmetic.html index 522b8b5..8480d22 100644 --- a/doc/arithmetic.html +++ b/doc/arithmetic.html @@ -1,4 +1,4 @@ - + @@ -123,10 +123,10 @@ namespace struct header { - big_int32_t file_code; - big_int32_t file_length; - little_int32_t version; - little_int32_t shape_type; + big_int32_at file_code; + big_int32_at file_length; + little_int32_at version; + little_int32_at shape_type; }; const char* filename = "test.dat"; @@ -219,7 +219,7 @@ enum class align {no, yes}; class endian_arithmetic; -

Typedefs, such as big_int32_ut, provide convenient naming +

Typedefs, such as big_int32_t, provide convenient naming conventions for common use cases:

@@ -231,112 +231,112 @@ conventions for common use cases:

- + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - + @@ -434,107 +434,107 @@ usual operations on integers are supplied.

// typedefs // aligned big endian floating point types - typedef endian<order::big, float, 32, align::yes> big_float32_t; - typedef endian<order::big, double, 64, align::yes> big_float64_t; + typedef endian<order::big, float, 32, align::yes> big_float32_at; + typedef endian<order::big, double, 64, align::yes> big_float64_at; // aligned little endian floating point types - typedef endian<order::little, float, 32, align::yes> little_float32_t; - typedef endian<order::little, double, 64, align::yes> little_float64_t; + typedef endian<order::little, float, 32, align::yes> little_float32_at; + typedef endian<order::little, double, 64, align::yes> little_float64_at; // unaligned big endian floating point types - typedef endian<order::big, float, 32, align::no> big_float32_ut; - typedef endian<order::big, double, 64, align::no> big_float64_ut; + typedef endian<order::big, float, 32, align::no> big_float32_t; + typedef endian<order::big, double, 64, align::no> big_float64_t; // unaligned little endian floating point types - typedef endian<order::little, float, 32, align::no> little_float32_ut; - typedef endian<order::little, double, 64, align::no> little_float64_ut; + typedef endian<order::little, float, 32, align::no> little_float32_t; + typedef endian<order::little, double, 64, align::no> little_float64_t; // aligned big endian signed integer types - typedef endian<order::big, int8_t, 8, align::yes> big_int8_t; - typedef endian<order::big, int16_t, 16, align::yes> big_int16_t; - typedef endian<order::big, int32_t, 32, align::yes> big_int32_t; - typedef endian<order::big, int64_t, 64, align::yes> big_int64_t; + typedef endian<order::big, int8_t, 8, align::yes> big_int8_at; + typedef endian<order::big, int16_t, 16, align::yes> big_int16_at; + typedef endian<order::big, int32_t, 32, align::yes> big_int32_at; + typedef endian<order::big, int64_t, 64, align::yes> big_int64_at; // aligned big endian unsigned integer types - typedef endian<order::big, uint8_t, 8, align::yes> big_uint8_t; - typedef endian<order::big, uint16_t, 16, align::yes> big_uint16_t; - typedef endian<order::big, uint32_t, 32, align::yes> big_uint32_t; - typedef endian<order::big, uint64_t, 64, align::yes> big_uint64_t; + typedef endian<order::big, uint8_t, 8, align::yes> big_uint8_at; + typedef endian<order::big, uint16_t, 16, align::yes> big_uint16_at; + typedef endian<order::big, uint32_t, 32, align::yes> big_uint32_at; + typedef endian<order::big, uint64_t, 64, align::yes> big_uint64_at; // aligned little endian signed integer types - typedef endian<order::little, int8_t, 8, align::yes> little_int8_t; - typedef endian<order::little, int16_t, 16, align::yes> little_int16_t; - typedef endian<order::little, int32_t, 32, align::yes> little_int32_t; - typedef endian<order::little, int64_t, 64, align::yes> little_int64_t; + typedef endian<order::little, int8_t, 8, align::yes> little_int8_at; + typedef endian<order::little, int16_t, 16, align::yes> little_int16_at; + typedef endian<order::little, int32_t, 32, align::yes> little_int32_at; + typedef endian<order::little, int64_t, 64, align::yes> little_int64_at; // aligned little endian unsigned integer types - typedef endian<order::little, uint8_t, 8, align::yes> little_uint8_t; - typedef endian<order::little, uint16_t, 16, align::yes> little_uint16_t; - typedef endian<order::little, uint32_t, 32, align::yes> little_uint32_t; - typedef endian<order::little, uint64_t, 64, align::yes> little_uint64_t; + typedef endian<order::little, uint8_t, 8, align::yes> little_uint8_at; + typedef endian<order::little, uint16_t, 16, align::yes> little_uint16_at; + typedef endian<order::little, uint32_t, 32, align::yes> little_uint32_at; + typedef endian<order::little, uint64_t, 64, align::yes> little_uint64_at; // aligned native endian typedefs are not provided because // <cstdint> types are superior for that use case // unaligned big endian signed integer types - typedef endian<order::big, int_least8_t, 8> big_int8_ut; - typedef endian<order::big, int_least16_t, 16> big_int16_ut; - typedef endian<order::big, int_least32_t, 24> big_int24_ut; - typedef endian<order::big, int_least32_t, 32> big_int32_ut; - typedef endian<order::big, int_least64_t, 40> big_int40_ut; - typedef endian<order::big, int_least64_t, 48> big_int48_ut; - typedef endian<order::big, int_least64_t, 56> big_int56_ut; - typedef endian<order::big, int_least64_t, 64> big_int64_ut; + typedef endian<order::big, int_least8_t, 8> big_int8_t; + typedef endian<order::big, int_least16_t, 16> big_int16_t; + typedef endian<order::big, int_least32_t, 24> big_int24_t; + typedef endian<order::big, int_least32_t, 32> big_int32_t; + typedef endian<order::big, int_least64_t, 40> big_int40_t; + typedef endian<order::big, int_least64_t, 48> big_int48_t; + typedef endian<order::big, int_least64_t, 56> big_int56_t; + typedef endian<order::big, int_least64_t, 64> big_int64_t; // unaligned big endian unsigned integer types - typedef endian<order::big, uint_least8_t, 8> big_uint8_ut; - typedef endian<order::big, uint_least16_t, 16> big_uint16_ut; - typedef endian<order::big, uint_least32_t, 24> big_uint24_ut; - typedef endian<order::big, uint_least32_t, 32> big_uint32_ut; - typedef endian<order::big, uint_least64_t, 40> big_uint40_ut; - typedef endian<order::big, uint_least64_t, 48> big_uint48_ut; - typedef endian<order::big, uint_least64_t, 56> big_uint56_ut; - typedef endian<order::big, uint_least64_t, 64> big_uint64_ut; + typedef endian<order::big, uint_least8_t, 8> big_uint8_t; + typedef endian<order::big, uint_least16_t, 16> big_uint16_t; + typedef endian<order::big, uint_least32_t, 24> big_uint24_t; + typedef endian<order::big, uint_least32_t, 32> big_uint32_t; + typedef endian<order::big, uint_least64_t, 40> big_uint40_t; + typedef endian<order::big, uint_least64_t, 48> big_uint48_t; + typedef endian<order::big, uint_least64_t, 56> big_uint56_t; + typedef endian<order::big, uint_least64_t, 64> big_uint64_t; // unaligned little endian signed integer types - typedef endian<order::little, int_least8_t, 8> little_int8_ut; - typedef endian<order::little, int_least16_t, 16> little_int16_ut; - typedef endian<order::little, int_least32_t, 24> little_int24_ut; - typedef endian<order::little, int_least32_t, 32> little_int32_ut; - typedef endian<order::little, int_least64_t, 40> little_int40_ut; - typedef endian<order::little, int_least64_t, 48> little_int48_ut; - typedef endian<order::little, int_least64_t, 56> little_int56_ut; - typedef endian<order::little, int_least64_t, 64> little_int64_ut; + typedef endian<order::little, int_least8_t, 8> little_int8_t; + typedef endian<order::little, int_least16_t, 16> little_int16_t; + typedef endian<order::little, int_least32_t, 24> little_int24_t; + typedef endian<order::little, int_least32_t, 32> little_int32_t; + typedef endian<order::little, int_least64_t, 40> little_int40_t; + typedef endian<order::little, int_least64_t, 48> little_int48_t; + typedef endian<order::little, int_least64_t, 56> little_int56_t; + typedef endian<order::little, int_least64_t, 64> little_int64_t; // unaligned little endian unsigned integer types - typedef endian<order::little, uint_least8_t, 8> little_uint8_ut; - typedef endian<order::little, uint_least16_t, 16> little_uint16_ut; - typedef endian<order::little, uint_least32_t, 24> little_uint24_ut; - typedef endian<order::little, uint_least32_t, 32> little_uint32_ut; - typedef endian<order::little, uint_least64_t, 40> little_uint40_ut; - typedef endian<order::little, uint_least64_t, 48> little_uint48_ut; - typedef endian<order::little, uint_least64_t, 56> little_uint56_ut; - typedef endian<order::little, uint_least64_t, 64> little_uint64_ut; + typedef endian<order::little, uint_least8_t, 8> little_uint8_t; + typedef endian<order::little, uint_least16_t, 16> little_uint16_t; + typedef endian<order::little, uint_least32_t, 24> little_uint24_t; + typedef endian<order::little, uint_least32_t, 32> little_uint32_t; + typedef endian<order::little, uint_least64_t, 40> little_uint40_t; + typedef endian<order::little, uint_least64_t, 48> little_uint48_t; + typedef endian<order::little, uint_least64_t, 56> little_uint56_t; + typedef endian<order::little, uint_least64_t, 64> little_uint64_t; // unaligned native endian signed integer types - typedef implementation-defined_int8_t native_int8_ut; - typedef implementation-defined_int16_t native_int16_ut; - typedef implementation-defined_int24_t native_int24_ut; - typedef implementation-defined_int32_t native_int32_ut; - typedef implementation-defined_int40_t native_int40_ut; - typedef implementation-defined_int48_t native_int48_ut; - typedef implementation-defined_int56_t native_int56_ut; - typedef implementation-defined_int64_t native_int64_ut; + typedef implementation-defined_int8_t native_int8_t; + typedef implementation-defined_int16_t native_int16_t; + typedef implementation-defined_int24_t native_int24_t; + typedef implementation-defined_int32_t native_int32_t; + typedef implementation-defined_int40_t native_int40_t; + typedef implementation-defined_int48_t native_int48_t; + typedef implementation-defined_int56_t native_int56_t; + typedef implementation-defined_int64_t native_int64_t; // unaligned native endian unsigned integer types - typedef implementation-defined_uint8_t native_uint8_ut; - typedef implementation-defined_uint16_t native_uint16_ut; - typedef implementation-defined_uint24_t native_uint24_ut; - typedef implementation-defined_uint32_t native_uint32_ut; - typedef implementation-defined_uint40_t native_uint40_ut; - typedef implementation-defined_uint48_t native_uint48_ut; - typedef implementation-defined_uint56_t native_uint56_ut; - typedef implementation-defined_uint64_t native_uint64_ut; + typedef implementation-defined_uint8_t native_uint8_t; + typedef implementation-defined_uint16_t native_uint16_t; + typedef implementation-defined_uint24_t native_uint24_t; + typedef implementation-defined_uint32_t native_uint32_t; + typedef implementation-defined_uint40_t native_uint40_t; + typedef implementation-defined_uint48_t native_uint48_t; + typedef implementation-defined_uint56_t native_uint56_t; + typedef implementation-defined_uint64_t native_uint64_t; } // namespace endian } // namespace boost diff --git a/doc/buffers.html b/doc/buffers.html index dceec38..d234d03 100644 --- a/doc/buffers.html +++ b/doc/buffers.html @@ -1,4 +1,4 @@ - + @@ -201,7 +201,7 @@ enum class align {no, yes}; class endian_buffer; -

Typedefs, such as big_int32_buf_ut, provide convenient naming +

Typedefs, such as big_int32_buf_t, provide convenient naming conventions for common use cases:

Sizes in bits (n)
big_intn_utbig_intn_t no big signed 8,16,24,32,40,48,56,64
big_uintn_utnobigunsigned8,16,24,32,40,48,56,64
big_floatn_utnobigsigned32,64
little_intn_utnolittlesigned8,16,24,32,40,48,56,64
little_uintn_utnolittleunsigned8,16,24,32,40,48,56,64
little_floatn_utnolittlesigned32,64
native_intn_utnonativesigned8,16,24,32,40,48,56,64
native_uintn_utnonativeunsigned8,16,24,32,40,48,56,64
native_floatn_utnonativesigned32,64
big_intn_tyesbigsigned8,16,32,64
big_uintn_tnobigunsigned8,16,24,32,40,48,56,64
big_floatn_tnobigsigned32,64
little_intn_tnolittlesigned8,16,24,32,40,48,56,64
little_uintn_tnolittleunsigned8,16,24,32,40,48,56,64
little_floatn_tnolittlesigned32,64
native_intn_tnonativesigned8,16,24,32,40,48,56,64
native_uintn_tnonativeunsigned8,16,24,32,40,48,56,64
native_floatn_tnonativesigned32,64
big_intn_atyesbigsigned8,16,32,64
big_uintn_at yes big unsigned 8,16,32,64
big_floatn_tbig_floatn_at yes big signed 32,64
little_intn_tlittle_intn_at yes little signed 8,16,32,64
little_uintn_tlittle_uintn_at yes little unsigned 8,16,32,64
little_floatn_tlittle_floatn_at yes little signed 32,64
native_floatn_tnative_floatn_at yes native signed
@@ -213,70 +213,70 @@ conventions for common use cases:

- + - + - + - + - + - + - + - + - + - + @@ -399,107 +399,107 @@ usual operations on integers are supplied.

// typedefs // aligned big endian floating point buffers - typedef endian_buffer<order::big, float, 32, align::yes> big_float32_buf_t; - typedef endian_buffer<order::big, double, 64, align::yes> big_float64_buf_t; + typedef endian_buffer<order::big, float, 32, align::yes> big_float32_buf_at; + typedef endian_buffer<order::big, double, 64, align::yes> big_float64_buf_at; // aligned little endian floating point buffers - typedef endian_buffer<order::little, float, 32, align::yes> little_float32_buf_t; - typedef endian_buffer<order::little, double, 64, align::yes> little_float64_buf_t; + typedef endian_buffer<order::little, float, 32, align::yes> little_float32_buf_at; + typedef endian_buffer<order::little, double, 64, align::yes> little_float64_buf_at; // unaligned big endian floating point buffers - typedef endian_buffer<order::big, float, 32, align::no> big_float32_buf_ut; - typedef endian_buffer<order::big, double, 64, align::no> big_float64_buf_ut; + typedef endian_buffer<order::big, float, 32, align::no> big_float32_buf_t; + typedef endian_buffer<order::big, double, 64, align::no> big_float64_buf_t; // unaligned little endian floating point buffers - typedef endian_buffer<order::little, float, 32, align::no> little_float32_buf_ut; - typedef endian_buffer<order::little, double, 64, align::no> little_float64_buf_ut; + typedef endian_buffer<order::little, float, 32, align::no> little_float32_buf_t; + typedef endian_buffer<order::little, double, 64, align::no> little_float64_buf_t; // aligned big endian signed integer buffers - typedef endian_buffer<order::big, int8_t, 8, align::yes> big_int8_buf_t; - typedef endian_buffer<order::big, int16_t, 16, align::yes> big_int16_buf_t; - typedef endian_buffer<order::big, int32_t, 32, align::yes> big_int32_buf_t; - typedef endian_buffer<order::big, int64_t, 64, align::yes> big_int64_buf_t; + typedef endian_buffer<order::big, int8_t, 8, align::yes> big_int8_buf_at; + typedef endian_buffer<order::big, int16_t, 16, align::yes> big_int16_buf_at; + typedef endian_buffer<order::big, int32_t, 32, align::yes> big_int32_buf_at; + typedef endian_buffer<order::big, int64_t, 64, align::yes> big_int64_buf_at; // aligned big endian unsigned integer buffers - typedef endian_buffer<order::big, uint8_t, 8, align::yes> big_uint8_buf_t; - typedef endian_buffer<order::big, uint16_t, 16, align::yes> big_uint16_buf_t; - typedef endian_buffer<order::big, uint32_t, 32, align::yes> big_uint32_buf_t; - typedef endian_buffer<order::big, uint64_t, 64, align::yes> big_uint64_buf_t; + typedef endian_buffer<order::big, uint8_t, 8, align::yes> big_uint8_buf_at; + typedef endian_buffer<order::big, uint16_t, 16, align::yes> big_uint16_buf_at; + typedef endian_buffer<order::big, uint32_t, 32, align::yes> big_uint32_buf_at; + typedef endian_buffer<order::big, uint64_t, 64, align::yes> big_uint64_buf_at; // aligned little endian signed integer buffers - typedef endian_buffer<order::little, int8_t, 8, align::yes> little_int8_buf_t; - typedef endian_buffer<order::little, int16_t, 16, align::yes> little_int16_buf_t; - typedef endian_buffer<order::little, int32_t, 32, align::yes> little_int32_buf_t; - typedef endian_buffer<order::little, int64_t, 64, align::yes> little_int64_buf_t; + typedef endian_buffer<order::little, int8_t, 8, align::yes> little_int8_buf_at; + typedef endian_buffer<order::little, int16_t, 16, align::yes> little_int16_buf_at; + typedef endian_buffer<order::little, int32_t, 32, align::yes> little_int32_buf_at; + typedef endian_buffer<order::little, int64_t, 64, align::yes> little_int64_buf_at; // aligned little endian unsigned integer buffers - typedef endian_buffer<order::little, uint8_t, 8, align::yes> little_uint8_buf_t; - typedef endian_buffer<order::little, uint16_t, 16, align::yes> little_uint16_buf_t; - typedef endian_buffer<order::little, uint32_t, 32, align::yes> little_uint32_buf_t; - typedef endian_buffer<order::little, uint64_t, 64, align::yes> little_uint64_buf_t; + typedef endian_buffer<order::little, uint8_t, 8, align::yes> little_uint8_buf_at; + typedef endian_buffer<order::little, uint16_t, 16, align::yes> little_uint16_buf_at; + typedef endian_buffer<order::little, uint32_t, 32, align::yes> little_uint32_buf_at; + typedef endian_buffer<order::little, uint64_t, 64, align::yes> little_uint64_buf_at; // aligned native endian typedefs are not provided because // <cstdint> types are superior for this use case // unaligned big endian signed integer buffers - typedef endian_buffer<order::big, int_least8_t, 8> big_int8_buf_ut; - typedef endian_buffer<order::big, int_least16_t, 16> big_int16_buf_ut; - typedef endian_buffer<order::big, int_least32_t, 24> big_int24_buf_ut; - typedef endian_buffer<order::big, int_least32_t, 32> big_int32_buf_ut; - typedef endian_buffer<order::big, int_least64_t, 40> big_int40_buf_ut; - typedef endian_buffer<order::big, int_least64_t, 48> big_int48_buf_ut; - typedef endian_buffer<order::big, int_least64_t, 56> big_int56_buf_ut; - typedef endian_buffer<order::big, int_least64_t, 64> big_int64_buf_ut; + typedef endian_buffer<order::big, int_least8_t, 8> big_int8_buf_t; + typedef endian_buffer<order::big, int_least16_t, 16> big_int16_buf_t; + typedef endian_buffer<order::big, int_least32_t, 24> big_int24_buf_t; + typedef endian_buffer<order::big, int_least32_t, 32> big_int32_buf_t; + typedef endian_buffer<order::big, int_least64_t, 40> big_int40_buf_t; + typedef endian_buffer<order::big, int_least64_t, 48> big_int48_buf_t; + typedef endian_buffer<order::big, int_least64_t, 56> big_int56_buf_t; + typedef endian_buffer<order::big, int_least64_t, 64> big_int64_buf_t; // unaligned big endian unsigned integer buffers - typedef endian_buffer<order::big, uint_least8_t, 8> big_uint8_buf_ut; - typedef endian_buffer<order::big, uint_least16_t, 16> big_uint16_buf_ut; - typedef endian_buffer<order::big, uint_least32_t, 24> big_uint24_buf_ut; - typedef endian_buffer<order::big, uint_least32_t, 32> big_uint32_buf_ut; - typedef endian_buffer<order::big, uint_least64_t, 40> big_uint40_buf_ut; - typedef endian_buffer<order::big, uint_least64_t, 48> big_uint48_buf_ut; - typedef endian_buffer<order::big, uint_least64_t, 56> big_uint56_buf_ut; - typedef endian_buffer<order::big, uint_least64_t, 64> big_uint64_buf_ut; + typedef endian_buffer<order::big, uint_least8_t, 8> big_uint8_buf_t; + typedef endian_buffer<order::big, uint_least16_t, 16> big_uint16_buf_t; + typedef endian_buffer<order::big, uint_least32_t, 24> big_uint24_buf_t; + typedef endian_buffer<order::big, uint_least32_t, 32> big_uint32_buf_t; + typedef endian_buffer<order::big, uint_least64_t, 40> big_uint40_buf_t; + typedef endian_buffer<order::big, uint_least64_t, 48> big_uint48_buf_t; + typedef endian_buffer<order::big, uint_least64_t, 56> big_uint56_buf_t; + typedef endian_buffer<order::big, uint_least64_t, 64> big_uint64_buf_t; // unaligned little endian signed integer buffers - typedef endian_buffer<order::little, int_least8_t, 8> little_int8_buf_ut; - typedef endian_buffer<order::little, int_least16_t, 16> little_int16_buf_ut; - typedef endian_buffer<order::little, int_least32_t, 24> little_int24_buf_ut; - typedef endian_buffer<order::little, int_least32_t, 32> little_int32_buf_ut; - typedef endian_buffer<order::little, int_least64_t, 40> little_int40_buf_ut; - typedef endian_buffer<order::little, int_least64_t, 48> little_int48_buf_ut; - typedef endian_buffer<order::little, int_least64_t, 56> little_int56_buf_ut; - typedef endian_buffer<order::little, int_least64_t, 64> little_int64_buf_ut; + typedef endian_buffer<order::little, int_least8_t, 8> little_int8_buf_t; + typedef endian_buffer<order::little, int_least16_t, 16> little_int16_buf_t; + typedef endian_buffer<order::little, int_least32_t, 24> little_int24_buf_t; + typedef endian_buffer<order::little, int_least32_t, 32> little_int32_buf_t; + typedef endian_buffer<order::little, int_least64_t, 40> little_int40_buf_t; + typedef endian_buffer<order::little, int_least64_t, 48> little_int48_buf_t; + typedef endian_buffer<order::little, int_least64_t, 56> little_int56_buf_t; + typedef endian_buffer<order::little, int_least64_t, 64> little_int64_buf_t; // unaligned little endian unsigned integer buffers - typedef endian_buffer<order::little, uint_least8_t, 8> little_uint8_buf_ut; - typedef endian_buffer<order::little, uint_least16_t, 16> little_uint16_buf_ut; - typedef endian_buffer<order::little, uint_least32_t, 24> little_uint24_buf_ut; - typedef endian_buffer<order::little, uint_least32_t, 32> little_uint32_buf_ut; - typedef endian_buffer<order::little, uint_least64_t, 40> little_uint40_buf_ut; - typedef endian_buffer<order::little, uint_least64_t, 48> little_uint48_buf_ut; - typedef endian_buffer<order::little, uint_least64_t, 56> little_uint56_buf_ut; - typedef endian_buffer<order::little, uint_least64_t, 64> little_uint64_buf_ut; + typedef endian_buffer<order::little, uint_least8_t, 8> little_uint8_buf_t; + typedef endian_buffer<order::little, uint_least16_t, 16> little_uint16_buf_t; + typedef endian_buffer<order::little, uint_least32_t, 24> little_uint24_buf_t; + typedef endian_buffer<order::little, uint_least32_t, 32> little_uint32_buf_t; + typedef endian_buffer<order::little, uint_least64_t, 40> little_uint40_buf_t; + typedef endian_buffer<order::little, uint_least64_t, 48> little_uint48_buf_t; + typedef endian_buffer<order::little, uint_least64_t, 56> little_uint56_buf_t; + typedef endian_buffer<order::little, uint_least64_t, 64> little_uint64_buf_t; // unaligned native endian signed integer types - typedef implementation-defined_int8_buf_ut native_int8_buf_ut; - typedef implementation-defined_int16_buf_ut native_int16_buf_ut; - typedef implementation-defined_int24_buf_ut native_int24_buf_ut; - typedef implementation-defined_int32_buf_ut native_int32_buf_ut; - typedef implementation-defined_int40_buf_ut native_int40_buf_ut; - typedef implementation-defined_int48_buf_ut native_int48_buf_ut; - typedef implementation-defined_int56_buf_ut native_int56_buf_ut; - typedef implementation-defined_int64_buf_ut native_int64_buf_ut; + typedef implementation-defined_int8_buf_t native_int8_buf_t; + typedef implementation-defined_int16_buf_t native_int16_buf_t; + typedef implementation-defined_int24_buf_t native_int24_buf_t; + typedef implementation-defined_int32_buf_t native_int32_buf_t; + typedef implementation-defined_int40_buf_t native_int40_buf_t; + typedef implementation-defined_int48_buf_t native_int48_buf_t; + typedef implementation-defined_int56_buf_t native_int56_buf_t; + typedef implementation-defined_int64_buf_t native_int64_buf_t; // unaligned native endian unsigned integer types - typedef implementation-defined_uint8_buf_ut native_uint8_buf_ut; - typedef implementation-defined_uint16_buf_ut native_uint16_buf_ut; - typedef implementation-defined_uint24_buf_ut native_uint24_buf_ut; - typedef implementation-defined_uint32_buf_ut native_uint32_buf_ut; - typedef implementation-defined_uint40_buf_ut native_uint40_buf_ut; - typedef implementation-defined_uint48_buf_ut native_uint48_buf_ut; - typedef implementation-defined_uint56_buf_ut native_uint56_buf_ut; - typedef implementation-defined_uint64_buf_ut native_uint64_buf_ut; + typedef implementation-defined_uint8_buf_t native_uint8_buf_t; + typedef implementation-defined_uint16_buf_t native_uint16_buf_t; + typedef implementation-defined_uint24_buf_t native_uint24_buf_t; + typedef implementation-defined_uint32_buf_t native_uint32_buf_t; + typedef implementation-defined_uint40_buf_t native_uint40_buf_t; + typedef implementation-defined_uint48_buf_t native_uint48_buf_t; + typedef implementation-defined_uint56_buf_t native_uint56_buf_t; + typedef implementation-defined_uint64_buf_t native_uint64_buf_t; } // namespace endian } // namespace boost diff --git a/doc/index.html b/doc/index.html index b651d6c..ef60547 100644 --- a/doc/index.html +++ b/doc/index.html @@ -1,4 +1,4 @@ - + @@ -219,7 +219,7 @@ intrinsics as a source of performance issues.

"; - time(); + time(); cout << "\n"; } void test_little_align_int16() { cout << ""; - time(); + time(); cout << "\n"; } void test_big_int16() { cout << ""; - time(); + time(); cout << "\n"; } void test_little_int16() { cout << ""; - time(); + time(); cout << "\n"; } void test_big_align_int32() { cout << ""; - time(); + time(); cout << "\n"; } void test_little_align_int32() { cout << ""; - time(); + time(); cout << "\n"; } void test_big_int32() { cout << ""; - time(); + time(); cout << "\n"; } void test_little_int32() { cout << ""; - time(); + time(); cout << "\n"; } void test_big_align_int64() { cout << ""; - time(); + time(); cout << "\n"; } void test_little_align_int64() { cout << ""; - time(); + time(); cout << "\n"; } void test_big_int64() { cout << ""; - time(); + time(); cout << "\n"; } void test_little_int64() { cout << ""; - time(); + time(); cout << "\n"; }
Sizes in bits (n)
big_intn_buf_utbig_intn_buf_t no big signed 8,16,24,32,40,48,56,64
big_uintn_buf_utbig_uintn_buf_t no big unsigned 8,16,24,32,40,48,56,64
big_floatn_buf_utbig_floatn_buf_t no big signed 32,64
little_intn_buf_utlittle_intn_buf_t no little signed 8,16,24,32,40,48,56,64
little_uintn_buf_utlittle_uintn_buf_t no little unsigned 8,16,24,32,40,48,56,64
little_floatn_buf_utlittle_floatn_buf_t no little signed 32,64
native_intn_buf_utnative_intn_buf_t no native signed 8,16,24,32,40,48,56,64
native_uintn_buf_utnative_uintn_buf_t no native unsigned 8,16,24,32,40,48,56,64
native_floatn_buf_utnative_floatn_buf_t no native signed 32,64
big_intn_buf_tbig_intn_buf_at yes big signed
- 
big_int32_t x;
+    
big_int32_at x;
 
 ... read into x from a file ...
 
@@ -273,7 +273,7 @@ spent doing I/O will determine the speed of this application.
- 
big_int32_t x;
+    
big_int32_at x;
 
 ... read into x from a file ...
 
@@ -395,7 +395,7 @@ I/O formats? 

 

 
Using the unaligned integer types with a size tailored to the application's 
 needs is a minor secondary use that saves internal or external memory space. For 
-example, using big_int40_buf_ut or big_int40_ut in a 
+example, using big_int40_buf_t or big_int40_t in a 
 large array saves a lot of space compared to one of the 64-bit types.

 

 
Why bother with binary I/O? Why not just use C++ Standard Library stream 
diff --git a/example/endian_example.cpp b/example/endian_example.cpp
index 3cdcfa0..b9e17ec 100644
--- a/example/endian_example.cpp
+++ b/example/endian_example.cpp
@@ -27,10 +27,10 @@ namespace
 
   struct header
   {
-    big_int32_buf_t     file_code;
-    big_int32_buf_t     file_length;
-    little_int32_buf_t  version;
-    little_int32_buf_t  shape_type;
+    big_int32_buf_at     file_code;
+    big_int32_buf_at     file_length;
+    little_int32_buf_at  version;
+    little_int32_buf_at  shape_type;
   };
 
   const char* filename = "test.dat";
diff --git a/include/boost/endian/arithmetic.hpp b/include/boost/endian/arithmetic.hpp
index e967adc..cb0168d 100644
--- a/include/boost/endian/arithmetic.hpp
+++ b/include/boost/endian/arithmetic.hpp
@@ -80,140 +80,140 @@ namespace endian
       class endian_arithmetic;
 
   // big endian floating point aligned types
-  typedef endian_arithmetic       big_float32_t;
-  typedef endian_arithmetic      big_float64_t;
+  typedef endian_arithmetic       big_float32_at;
+  typedef endian_arithmetic      big_float64_at;
 
   // little endian floating point aligned types
-  typedef endian_arithmetic    little_float32_t;
-  typedef endian_arithmetic   little_float64_t;
+  typedef endian_arithmetic    little_float32_at;
+  typedef endian_arithmetic   little_float64_at;
 
   // big endian floating point unaligned types
-  typedef endian_arithmetic        big_float32_ut;
-  typedef endian_arithmetic       big_float64_ut;
+  typedef endian_arithmetic        big_float32_t;
+  typedef endian_arithmetic       big_float64_t;
 
   // little endian floating point unaligned types
-  typedef endian_arithmetic     little_float32_ut;
-  typedef endian_arithmetic    little_float64_ut;
+  typedef endian_arithmetic     little_float32_t;
+  typedef endian_arithmetic    little_float64_t;
 
   // big endian signed integer aligned types
-  typedef endian_arithmetic        big_int8_t;
-  typedef endian_arithmetic      big_int16_t;
-  typedef endian_arithmetic      big_int32_t;
-  typedef endian_arithmetic      big_int64_t;
+  typedef endian_arithmetic        big_int8_at;
+  typedef endian_arithmetic      big_int16_at;
+  typedef endian_arithmetic      big_int32_at;
+  typedef endian_arithmetic      big_int64_at;
 
   // big endian unsigned integer aligned types
-  typedef endian_arithmetic       big_uint8_t;
-  typedef endian_arithmetic     big_uint16_t;
-  typedef endian_arithmetic     big_uint32_t;
-  typedef endian_arithmetic     big_uint64_t;
+  typedef endian_arithmetic       big_uint8_at;
+  typedef endian_arithmetic     big_uint16_at;
+  typedef endian_arithmetic     big_uint32_at;
+  typedef endian_arithmetic     big_uint64_at;
 
   // little endian signed integer aligned types
-  typedef endian_arithmetic     little_int8_t;
-  typedef endian_arithmetic   little_int16_t;
-  typedef endian_arithmetic   little_int32_t;
-  typedef endian_arithmetic   little_int64_t;
+  typedef endian_arithmetic     little_int8_at;
+  typedef endian_arithmetic   little_int16_at;
+  typedef endian_arithmetic   little_int32_at;
+  typedef endian_arithmetic   little_int64_at;
 
   // little endian unsigned integer aligned types
-  typedef endian_arithmetic    little_uint8_t;
-  typedef endian_arithmetic  little_uint16_t;
-  typedef endian_arithmetic  little_uint32_t;
-  typedef endian_arithmetic  little_uint64_t;
+  typedef endian_arithmetic    little_uint8_at;
+  typedef endian_arithmetic  little_uint16_at;
+  typedef endian_arithmetic  little_uint32_at;
+  typedef endian_arithmetic  little_uint64_at;
 
   // aligned native endian typedefs are not provided because
   //  types are superior for this use case
 
   // big endian signed integer unaligned types
-  typedef endian_arithmetic        big_int8_ut;
-  typedef endian_arithmetic      big_int16_ut;
-  typedef endian_arithmetic      big_int24_ut;
-  typedef endian_arithmetic      big_int32_ut;
-  typedef endian_arithmetic      big_int40_ut;
-  typedef endian_arithmetic      big_int48_ut;
-  typedef endian_arithmetic      big_int56_ut;
-  typedef endian_arithmetic      big_int64_ut;
+  typedef endian_arithmetic        big_int8_t;
+  typedef endian_arithmetic      big_int16_t;
+  typedef endian_arithmetic      big_int24_t;
+  typedef endian_arithmetic      big_int32_t;
+  typedef endian_arithmetic      big_int40_t;
+  typedef endian_arithmetic      big_int48_t;
+  typedef endian_arithmetic      big_int56_t;
+  typedef endian_arithmetic      big_int64_t;
 
   // big endian unsigned integer unaligned types
-  typedef endian_arithmetic       big_uint8_ut;
-  typedef endian_arithmetic     big_uint16_ut;
-  typedef endian_arithmetic     big_uint24_ut;
-  typedef endian_arithmetic     big_uint32_ut;
-  typedef endian_arithmetic     big_uint40_ut;
-  typedef endian_arithmetic     big_uint48_ut;
-  typedef endian_arithmetic     big_uint56_ut;
-  typedef endian_arithmetic     big_uint64_ut;
+  typedef endian_arithmetic       big_uint8_t;
+  typedef endian_arithmetic     big_uint16_t;
+  typedef endian_arithmetic     big_uint24_t;
+  typedef endian_arithmetic     big_uint32_t;
+  typedef endian_arithmetic     big_uint40_t;
+  typedef endian_arithmetic     big_uint48_t;
+  typedef endian_arithmetic     big_uint56_t;
+  typedef endian_arithmetic     big_uint64_t;
 
   // little endian signed integer unaligned types
-  typedef endian_arithmetic     little_int8_ut;
-  typedef endian_arithmetic   little_int16_ut;
-  typedef endian_arithmetic   little_int24_ut;
-  typedef endian_arithmetic   little_int32_ut;
-  typedef endian_arithmetic   little_int40_ut;
-  typedef endian_arithmetic   little_int48_ut;
-  typedef endian_arithmetic   little_int56_ut;
-  typedef endian_arithmetic   little_int64_ut;
+  typedef endian_arithmetic     little_int8_t;
+  typedef endian_arithmetic   little_int16_t;
+  typedef endian_arithmetic   little_int24_t;
+  typedef endian_arithmetic   little_int32_t;
+  typedef endian_arithmetic   little_int40_t;
+  typedef endian_arithmetic   little_int48_t;
+  typedef endian_arithmetic   little_int56_t;
+  typedef endian_arithmetic   little_int64_t;
 
   // little endian unsigned integer unaligned types
-  typedef endian_arithmetic    little_uint8_ut;
-  typedef endian_arithmetic  little_uint16_ut;
-  typedef endian_arithmetic  little_uint24_ut;
-  typedef endian_arithmetic  little_uint32_ut;
-  typedef endian_arithmetic  little_uint40_ut;
-  typedef endian_arithmetic  little_uint48_ut;
-  typedef endian_arithmetic  little_uint56_ut;
-  typedef endian_arithmetic  little_uint64_ut;
+  typedef endian_arithmetic    little_uint8_t;
+  typedef endian_arithmetic  little_uint16_t;
+  typedef endian_arithmetic  little_uint24_t;
+  typedef endian_arithmetic  little_uint32_t;
+  typedef endian_arithmetic  little_uint40_t;
+  typedef endian_arithmetic  little_uint48_t;
+  typedef endian_arithmetic  little_uint56_t;
+  typedef endian_arithmetic  little_uint64_t;
 
 # ifdef BOOST_BIG_ENDIAN
   // native endian signed integer unaligned types
-  typedef big_int8_ut   native_int8_ut;
-  typedef big_int16_ut  native_int16_ut;
-  typedef big_int24_ut  native_int24_ut;
-  typedef big_int32_ut  native_int32_ut;
-  typedef big_int40_ut  native_int40_ut;
-  typedef big_int48_ut  native_int48_ut;
-  typedef big_int56_ut  native_int56_ut;
-  typedef big_int64_ut  native_int64_ut;
+  typedef big_int8_t   native_int8_t;
+  typedef big_int16_t  native_int16_t;
+  typedef big_int24_t  native_int24_t;
+  typedef big_int32_t  native_int32_t;
+  typedef big_int40_t  native_int40_t;
+  typedef big_int48_t  native_int48_t;
+  typedef big_int56_t  native_int56_t;
+  typedef big_int64_t  native_int64_t;
 
   // native endian unsigned integer unaligned types
-  typedef big_uint8_ut   native_uint8_ut;
-  typedef big_uint16_ut  native_uint16_ut;
-  typedef big_uint24_ut  native_uint24_ut;
-  typedef big_uint32_ut  native_uint32_ut;
-  typedef big_uint40_ut  native_uint40_ut;
-  typedef big_uint48_ut  native_uint48_ut;
-  typedef big_uint56_ut  native_uint56_ut;
-  typedef big_uint64_ut  native_uint64_ut;
+  typedef big_uint8_t   native_uint8_t;
+  typedef big_uint16_t  native_uint16_t;
+  typedef big_uint24_t  native_uint24_t;
+  typedef big_uint32_t  native_uint32_t;
+  typedef big_uint40_t  native_uint40_t;
+  typedef big_uint48_t  native_uint48_t;
+  typedef big_uint56_t  native_uint56_t;
+  typedef big_uint64_t  native_uint64_t;
 
   // native endian floating point types
-  typedef big_float32_ut native_float32_ut;
-  typedef big_float64_ut native_float64_ut;
   typedef big_float32_t native_float32_t;
   typedef big_float64_t native_float64_t;
+  typedef big_float32_at native_float32_at;
+  typedef big_float64_at native_float64_at;
 # else
   // native endian signed integer unaligned types
-  typedef little_int8_ut   native_int8_ut;
-  typedef little_int16_ut  native_int16_ut;
-  typedef little_int24_ut  native_int24_ut;
-  typedef little_int32_ut  native_int32_ut;
-  typedef little_int40_ut  native_int40_ut;
-  typedef little_int48_ut  native_int48_ut;
-  typedef little_int56_ut  native_int56_ut;
-  typedef little_int64_ut  native_int64_ut;
+  typedef little_int8_t   native_int8_t;
+  typedef little_int16_t  native_int16_t;
+  typedef little_int24_t  native_int24_t;
+  typedef little_int32_t  native_int32_t;
+  typedef little_int40_t  native_int40_t;
+  typedef little_int48_t  native_int48_t;
+  typedef little_int56_t  native_int56_t;
+  typedef little_int64_t  native_int64_t;
 
   // native endian unsigned integer unaligned types
-  typedef little_uint8_ut   native_uint8_ut;
-  typedef little_uint16_ut  native_uint16_ut;
-  typedef little_uint24_ut  native_uint24_ut;
-  typedef little_uint32_ut  native_uint32_ut;
-  typedef little_uint40_ut  native_uint40_ut;
-  typedef little_uint48_ut  native_uint48_ut;
-  typedef little_uint56_ut  native_uint56_ut;
-  typedef little_uint64_ut  native_uint64_ut;
+  typedef little_uint8_t   native_uint8_t;
+  typedef little_uint16_t  native_uint16_t;
+  typedef little_uint24_t  native_uint24_t;
+  typedef little_uint32_t  native_uint32_t;
+  typedef little_uint40_t  native_uint40_t;
+  typedef little_uint48_t  native_uint48_t;
+  typedef little_uint56_t  native_uint56_t;
+  typedef little_uint64_t  native_uint64_t;
 
   // native endian floating point types
-  typedef little_float32_ut native_float32_ut;
-  typedef little_float64_ut native_float64_ut;
   typedef little_float32_t native_float32_t;
   typedef little_float64_t native_float64_t;
+  typedef little_float32_at native_float32_at;
+  typedef little_float64_at native_float64_at;
 # endif
 
 # ifdef BOOST_ENDIAN_DEPRECATED_NAMES
diff --git a/include/boost/endian/buffers.hpp b/include/boost/endian/buffers.hpp
index da353b4..b8cf003 100644
--- a/include/boost/endian/buffers.hpp
+++ b/include/boost/endian/buffers.hpp
@@ -77,140 +77,140 @@ namespace endian
       class endian_buffer;
 
   // aligned big endian floating point buffers
-  typedef endian_buffer      big_float32_buf_t;
-  typedef endian_buffer     big_float64_buf_t;
+  typedef endian_buffer      big_float32_buf_at;
+  typedef endian_buffer     big_float64_buf_at;
 
   // aligned little endian floating point buffers
-  typedef endian_buffer   little_float32_buf_t;
-  typedef endian_buffer  little_float64_buf_t;
+  typedef endian_buffer   little_float32_buf_at;
+  typedef endian_buffer  little_float64_buf_at;
 
   // unaligned big endian floating point buffers
-  typedef endian_buffer       big_float32_buf_ut;
-  typedef endian_buffer      big_float64_buf_ut;
+  typedef endian_buffer       big_float32_buf_t;
+  typedef endian_buffer      big_float64_buf_t;
 
   // unaligned little endian floating point buffers
-  typedef endian_buffer    little_float32_buf_ut;
-  typedef endian_buffer   little_float64_buf_ut;
+  typedef endian_buffer    little_float32_buf_t;
+  typedef endian_buffer   little_float64_buf_t;
 
   // aligned big endian signed integer buffers
-  typedef endian_buffer       big_int8_buf_t;
-  typedef endian_buffer     big_int16_buf_t;
-  typedef endian_buffer     big_int32_buf_t;
-  typedef endian_buffer     big_int64_buf_t;
+  typedef endian_buffer       big_int8_buf_at;
+  typedef endian_buffer     big_int16_buf_at;
+  typedef endian_buffer     big_int32_buf_at;
+  typedef endian_buffer     big_int64_buf_at;
 
   // aligned big endian unsigned integer buffers
-  typedef endian_buffer      big_uint8_buf_t;
-  typedef endian_buffer    big_uint16_buf_t;
-  typedef endian_buffer    big_uint32_buf_t;
-  typedef endian_buffer    big_uint64_buf_t;
+  typedef endian_buffer      big_uint8_buf_at;
+  typedef endian_buffer    big_uint16_buf_at;
+  typedef endian_buffer    big_uint32_buf_at;
+  typedef endian_buffer    big_uint64_buf_at;
 
   // aligned little endian signed integer buffers
-  typedef endian_buffer    little_int8_buf_t;
-  typedef endian_buffer  little_int16_buf_t;
-  typedef endian_buffer  little_int32_buf_t;
-  typedef endian_buffer  little_int64_buf_t;
+  typedef endian_buffer    little_int8_buf_at;
+  typedef endian_buffer  little_int16_buf_at;
+  typedef endian_buffer  little_int32_buf_at;
+  typedef endian_buffer  little_int64_buf_at;
 
   // aligned little endian unsigned integer buffers
-  typedef endian_buffer   little_uint8_buf_t;
-  typedef endian_buffer little_uint16_buf_t;
-  typedef endian_buffer little_uint32_buf_t;
-  typedef endian_buffer little_uint64_buf_t;
+  typedef endian_buffer   little_uint8_buf_at;
+  typedef endian_buffer little_uint16_buf_at;
+  typedef endian_buffer little_uint32_buf_at;
+  typedef endian_buffer little_uint64_buf_at;
 
   // aligned native endian typedefs are not provided because
   //  types are superior for this use case
 
   // unaligned big endian signed integer buffers
-  typedef endian_buffer        big_int8_buf_ut;
-  typedef endian_buffer      big_int16_buf_ut;
-  typedef endian_buffer      big_int24_buf_ut;
-  typedef endian_buffer      big_int32_buf_ut;
-  typedef endian_buffer      big_int40_buf_ut;
-  typedef endian_buffer      big_int48_buf_ut;
-  typedef endian_buffer      big_int56_buf_ut;
-  typedef endian_buffer      big_int64_buf_ut;
+  typedef endian_buffer        big_int8_buf_t;
+  typedef endian_buffer      big_int16_buf_t;
+  typedef endian_buffer      big_int24_buf_t;
+  typedef endian_buffer      big_int32_buf_t;
+  typedef endian_buffer      big_int40_buf_t;
+  typedef endian_buffer      big_int48_buf_t;
+  typedef endian_buffer      big_int56_buf_t;
+  typedef endian_buffer      big_int64_buf_t;
 
   // unaligned big endian unsigned integer buffers
-  typedef endian_buffer       big_uint8_buf_ut;
-  typedef endian_buffer     big_uint16_buf_ut;
-  typedef endian_buffer     big_uint24_buf_ut;
-  typedef endian_buffer     big_uint32_buf_ut;
-  typedef endian_buffer     big_uint40_buf_ut;
-  typedef endian_buffer     big_uint48_buf_ut;
-  typedef endian_buffer     big_uint56_buf_ut;
-  typedef endian_buffer     big_uint64_buf_ut;
+  typedef endian_buffer       big_uint8_buf_t;
+  typedef endian_buffer     big_uint16_buf_t;
+  typedef endian_buffer     big_uint24_buf_t;
+  typedef endian_buffer     big_uint32_buf_t;
+  typedef endian_buffer     big_uint40_buf_t;
+  typedef endian_buffer     big_uint48_buf_t;
+  typedef endian_buffer     big_uint56_buf_t;
+  typedef endian_buffer     big_uint64_buf_t;
 
   // unaligned little endian signed integer buffers
-  typedef endian_buffer     little_int8_buf_ut;
-  typedef endian_buffer   little_int16_buf_ut;
-  typedef endian_buffer   little_int24_buf_ut;
-  typedef endian_buffer   little_int32_buf_ut;
-  typedef endian_buffer   little_int40_buf_ut;
-  typedef endian_buffer   little_int48_buf_ut;
-  typedef endian_buffer   little_int56_buf_ut;
-  typedef endian_buffer   little_int64_buf_ut;
+  typedef endian_buffer     little_int8_buf_t;
+  typedef endian_buffer   little_int16_buf_t;
+  typedef endian_buffer   little_int24_buf_t;
+  typedef endian_buffer   little_int32_buf_t;
+  typedef endian_buffer   little_int40_buf_t;
+  typedef endian_buffer   little_int48_buf_t;
+  typedef endian_buffer   little_int56_buf_t;
+  typedef endian_buffer   little_int64_buf_t;
 
   // unaligned little endian unsigned integer buffers
-  typedef endian_buffer    little_uint8_buf_ut;
-  typedef endian_buffer  little_uint16_buf_ut;
-  typedef endian_buffer  little_uint24_buf_ut;
-  typedef endian_buffer  little_uint32_buf_ut;
-  typedef endian_buffer  little_uint40_buf_ut;
-  typedef endian_buffer  little_uint48_buf_ut;
-  typedef endian_buffer  little_uint56_buf_ut;
-  typedef endian_buffer  little_uint64_buf_ut;
+  typedef endian_buffer    little_uint8_buf_t;
+  typedef endian_buffer  little_uint16_buf_t;
+  typedef endian_buffer  little_uint24_buf_t;
+  typedef endian_buffer  little_uint32_buf_t;
+  typedef endian_buffer  little_uint40_buf_t;
+  typedef endian_buffer  little_uint48_buf_t;
+  typedef endian_buffer  little_uint56_buf_t;
+  typedef endian_buffer  little_uint64_buf_t;
 
 # ifdef BOOST_BIG_ENDIAN
   // unaligned native endian signed integer buffers
-  typedef big_int8_buf_ut   native_int8_buf_ut;
-  typedef big_int16_buf_ut  native_int16_buf_ut;
-  typedef big_int24_buf_ut  native_int24_buf_ut;
-  typedef big_int32_buf_ut  native_int32_buf_ut;
-  typedef big_int40_buf_ut  native_int40_buf_ut;
-  typedef big_int48_buf_ut  native_int48_buf_ut;
-  typedef big_int56_buf_ut  native_int56_buf_ut;
-  typedef big_int64_buf_ut  native_int64_buf_ut;
+  typedef big_int8_buf_t   native_int8_buf_t;
+  typedef big_int16_buf_t  native_int16_buf_t;
+  typedef big_int24_buf_t  native_int24_buf_t;
+  typedef big_int32_buf_t  native_int32_buf_t;
+  typedef big_int40_buf_t  native_int40_buf_t;
+  typedef big_int48_buf_t  native_int48_buf_t;
+  typedef big_int56_buf_t  native_int56_buf_t;
+  typedef big_int64_buf_t  native_int64_buf_t;
 
   // unaligned native endian unsigned integer buffers
-  typedef big_uint8_buf_ut   native_uint8_buf_ut;
-  typedef big_uint16_buf_ut  native_uint16_buf_ut;
-  typedef big_uint24_buf_ut  native_uint24_buf_ut;
-  typedef big_uint32_buf_ut  native_uint32_buf_ut;
-  typedef big_uint40_buf_ut  native_uint40_buf_ut;
-  typedef big_uint48_buf_ut  native_uint48_buf_ut;
-  typedef big_uint56_buf_ut  native_uint56_buf_ut;
-  typedef big_uint64_buf_ut  native_uint64_buf_ut;
+  typedef big_uint8_buf_t   native_uint8_buf_t;
+  typedef big_uint16_buf_t  native_uint16_buf_t;
+  typedef big_uint24_buf_t  native_uint24_buf_t;
+  typedef big_uint32_buf_t  native_uint32_buf_t;
+  typedef big_uint40_buf_t  native_uint40_buf_t;
+  typedef big_uint48_buf_t  native_uint48_buf_t;
+  typedef big_uint56_buf_t  native_uint56_buf_t;
+  typedef big_uint64_buf_t  native_uint64_buf_t;
 
   // native endian floating point buffers
-  typedef big_float32_buf_ut native_float32_buf_ut;
-  typedef big_float64_buf_ut native_float64_buf_ut;
   typedef big_float32_buf_t native_float32_buf_t;
   typedef big_float64_buf_t native_float64_buf_t;
+  typedef big_float32_buf_at native_float32_buf_at;
+  typedef big_float64_buf_at native_float64_buf_at;
 # else
   // unaligned native endian signed integer buffers
-  typedef little_int8_buf_ut   native_int8_buf_ut;
-  typedef little_int16_buf_ut  native_int16_buf_ut;
-  typedef little_int24_buf_ut  native_int24_buf_ut;
-  typedef little_int32_buf_ut  native_int32_buf_ut;
-  typedef little_int40_buf_ut  native_int40_buf_ut;
-  typedef little_int48_buf_ut  native_int48_buf_ut;
-  typedef little_int56_buf_ut  native_int56_buf_ut;
-  typedef little_int64_buf_ut  native_int64_buf_ut;
+  typedef little_int8_buf_t   native_int8_buf_t;
+  typedef little_int16_buf_t  native_int16_buf_t;
+  typedef little_int24_buf_t  native_int24_buf_t;
+  typedef little_int32_buf_t  native_int32_buf_t;
+  typedef little_int40_buf_t  native_int40_buf_t;
+  typedef little_int48_buf_t  native_int48_buf_t;
+  typedef little_int56_buf_t  native_int56_buf_t;
+  typedef little_int64_buf_t  native_int64_buf_t;
 
   // unaligned native endian unsigned integer buffers
-  typedef little_uint8_buf_ut   native_uint8_buf_ut;
-  typedef little_uint16_buf_ut  native_uint16_buf_ut;
-  typedef little_uint24_buf_ut  native_uint24_buf_ut;
-  typedef little_uint32_buf_ut  native_uint32_buf_ut;
-  typedef little_uint40_buf_ut  native_uint40_buf_ut;
-  typedef little_uint48_buf_ut  native_uint48_buf_ut;
-  typedef little_uint56_buf_ut  native_uint56_buf_ut;
-  typedef little_uint64_buf_ut  native_uint64_buf_ut;
+  typedef little_uint8_buf_t   native_uint8_buf_t;
+  typedef little_uint16_buf_t  native_uint16_buf_t;
+  typedef little_uint24_buf_t  native_uint24_buf_t;
+  typedef little_uint32_buf_t  native_uint32_buf_t;
+  typedef little_uint40_buf_t  native_uint40_buf_t;
+  typedef little_uint48_buf_t  native_uint48_buf_t;
+  typedef little_uint56_buf_t  native_uint56_buf_t;
+  typedef little_uint64_buf_t  native_uint64_buf_t;
 
   // native endian floating point buffers
-  typedef little_float32_buf_ut native_float32_buf_ut;
-  typedef little_float64_buf_ut native_float64_buf_ut;
   typedef little_float32_buf_t native_float32_buf_t;
   typedef little_float64_buf_t native_float64_buf_t;
+  typedef little_float32_buf_at native_float32_buf_at;
+  typedef little_float64_buf_at native_float64_buf_at;
 # endif
 
   // Stream inserter
diff --git a/test/buffer_test.cpp b/test/buffer_test.cpp
index 5ea61fd..f04fdaa 100644
--- a/test/buffer_test.cpp
+++ b/test/buffer_test.cpp
@@ -30,6 +30,13 @@ namespace
   void check_size()
   {
 
+    BOOST_TEST_EQ(sizeof(big_float32_buf_at), 4u);
+    BOOST_TEST_EQ(sizeof(big_float64_buf_at), 8u);
+    BOOST_TEST_EQ(sizeof(little_float32_buf_at), 4u);
+    BOOST_TEST_EQ(sizeof(little_float64_buf_at), 8u);
+    BOOST_TEST_EQ(sizeof(native_float32_buf_at), 4u);
+    BOOST_TEST_EQ(sizeof(native_float64_buf_at), 8u);
+
     BOOST_TEST_EQ(sizeof(big_float32_buf_t), 4u);
     BOOST_TEST_EQ(sizeof(big_float64_buf_t), 8u);
     BOOST_TEST_EQ(sizeof(little_float32_buf_t), 4u);
@@ -37,86 +44,79 @@ namespace
     BOOST_TEST_EQ(sizeof(native_float32_buf_t), 4u);
     BOOST_TEST_EQ(sizeof(native_float64_buf_t), 8u);
 
-    BOOST_TEST_EQ(sizeof(big_float32_buf_ut), 4u);
-    BOOST_TEST_EQ(sizeof(big_float64_buf_ut), 8u);
-    BOOST_TEST_EQ(sizeof(little_float32_buf_ut), 4u);
-    BOOST_TEST_EQ(sizeof(little_float64_buf_ut), 8u);
-    BOOST_TEST_EQ(sizeof(native_float32_buf_ut), 4u);
-    BOOST_TEST_EQ(sizeof(native_float64_buf_ut), 8u);
-
-    BOOST_TEST_EQ(sizeof(big_int8_buf_ut), 1u);
-    BOOST_TEST_EQ(sizeof(big_int16_buf_ut), 2u);
-    BOOST_TEST_EQ(sizeof(big_int24_buf_ut), 3u);
-    BOOST_TEST_EQ(sizeof(big_int32_buf_ut), 4u);
-    BOOST_TEST_EQ(sizeof(big_int40_buf_ut), 5u);
-    BOOST_TEST_EQ(sizeof(big_int48_buf_ut), 6u);
-    BOOST_TEST_EQ(sizeof(big_int56_buf_ut), 7u);
-    BOOST_TEST_EQ(sizeof(big_int64_buf_ut), 8u);
-
-    BOOST_TEST_EQ(sizeof(big_uint8_buf_ut), 1u);
-    BOOST_TEST_EQ(sizeof(big_uint16_buf_ut), 2u);
-    BOOST_TEST_EQ(sizeof(big_uint24_buf_ut), 3u);
-    BOOST_TEST_EQ(sizeof(big_uint32_buf_ut), 4u);
-    BOOST_TEST_EQ(sizeof(big_uint40_buf_ut), 5u);
-    BOOST_TEST_EQ(sizeof(big_uint48_buf_ut), 6u);
-    BOOST_TEST_EQ(sizeof(big_uint56_buf_ut), 7u);
-    BOOST_TEST_EQ(sizeof(big_uint64_buf_ut), 8u);
-
-    BOOST_TEST_EQ(sizeof(little_int8_buf_ut), 1u);
-    BOOST_TEST_EQ(sizeof(little_int16_buf_ut), 2u);
-    BOOST_TEST_EQ(sizeof(little_int24_buf_ut), 3u);
-    BOOST_TEST_EQ(sizeof(little_int32_buf_ut), 4u);
-    BOOST_TEST_EQ(sizeof(little_int40_buf_ut), 5u);
-    BOOST_TEST_EQ(sizeof(little_int48_buf_ut), 6u);
-    BOOST_TEST_EQ(sizeof(little_int56_buf_ut), 7u);
-    BOOST_TEST_EQ(sizeof(little_int64_buf_ut), 8u);
-
-    BOOST_TEST_EQ(sizeof(little_uint8_buf_ut), 1u);
-    BOOST_TEST_EQ(sizeof(little_uint16_buf_ut), 2u);
-    BOOST_TEST_EQ(sizeof(little_uint24_buf_ut), 3u);
-    BOOST_TEST_EQ(sizeof(little_uint32_buf_ut), 4u);
-    BOOST_TEST_EQ(sizeof(little_uint40_buf_ut), 5u);
-    BOOST_TEST_EQ(sizeof(little_uint48_buf_ut), 6u);
-    BOOST_TEST_EQ(sizeof(little_uint56_buf_ut), 7u);
-    BOOST_TEST_EQ(sizeof(little_uint64_buf_ut), 8u);
-
-    BOOST_TEST_EQ(sizeof(native_int8_buf_ut), 1u);
-    BOOST_TEST_EQ(sizeof(native_int16_buf_ut), 2u);
-    BOOST_TEST_EQ(sizeof(native_int24_buf_ut), 3u);
-    BOOST_TEST_EQ(sizeof(native_int32_buf_ut), 4u);
-    BOOST_TEST_EQ(sizeof(native_int40_buf_ut), 5u);
-    BOOST_TEST_EQ(sizeof(native_int48_buf_ut), 6u);
-    BOOST_TEST_EQ(sizeof(native_int56_buf_ut), 7u);
-    BOOST_TEST_EQ(sizeof(native_int64_buf_ut), 8u);
-
-    BOOST_TEST_EQ(sizeof(native_uint8_buf_ut), 1u);
-    BOOST_TEST_EQ(sizeof(native_uint16_buf_ut), 2u);
-    BOOST_TEST_EQ(sizeof(native_uint24_buf_ut), 3u);
-    BOOST_TEST_EQ(sizeof(native_uint32_buf_ut), 4u);
-    BOOST_TEST_EQ(sizeof(native_uint40_buf_ut), 5u);
-    BOOST_TEST_EQ(sizeof(native_uint48_buf_ut), 6u);
-    BOOST_TEST_EQ(sizeof(native_uint56_buf_ut), 7u);
-    BOOST_TEST_EQ(sizeof(native_uint64_buf_ut), 8u);
-
     BOOST_TEST_EQ(sizeof(big_int8_buf_t), 1u);
     BOOST_TEST_EQ(sizeof(big_int16_buf_t), 2u);
+    BOOST_TEST_EQ(sizeof(big_int24_buf_t), 3u);
     BOOST_TEST_EQ(sizeof(big_int32_buf_t), 4u);
+    BOOST_TEST_EQ(sizeof(big_int40_buf_t), 5u);
+    BOOST_TEST_EQ(sizeof(big_int48_buf_t), 6u);
+    BOOST_TEST_EQ(sizeof(big_int56_buf_t), 7u);
     BOOST_TEST_EQ(sizeof(big_int64_buf_t), 8u);
 
     BOOST_TEST_EQ(sizeof(big_uint8_buf_t), 1u);
     BOOST_TEST_EQ(sizeof(big_uint16_buf_t), 2u);
+    BOOST_TEST_EQ(sizeof(big_uint24_buf_t), 3u);
     BOOST_TEST_EQ(sizeof(big_uint32_buf_t), 4u);
+    BOOST_TEST_EQ(sizeof(big_uint40_buf_t), 5u);
+    BOOST_TEST_EQ(sizeof(big_uint48_buf_t), 6u);
+    BOOST_TEST_EQ(sizeof(big_uint56_buf_t), 7u);
     BOOST_TEST_EQ(sizeof(big_uint64_buf_t), 8u);
 
     BOOST_TEST_EQ(sizeof(little_int8_buf_t), 1u);
     BOOST_TEST_EQ(sizeof(little_int16_buf_t), 2u);
+    BOOST_TEST_EQ(sizeof(little_int24_buf_t), 3u);
     BOOST_TEST_EQ(sizeof(little_int32_buf_t), 4u);
+    BOOST_TEST_EQ(sizeof(little_int40_buf_t), 5u);
+    BOOST_TEST_EQ(sizeof(little_int48_buf_t), 6u);
+    BOOST_TEST_EQ(sizeof(little_int56_buf_t), 7u);
     BOOST_TEST_EQ(sizeof(little_int64_buf_t), 8u);
 
     BOOST_TEST_EQ(sizeof(little_uint8_buf_t), 1u);
     BOOST_TEST_EQ(sizeof(little_uint16_buf_t), 2u);
+    BOOST_TEST_EQ(sizeof(little_uint24_buf_t), 3u);
     BOOST_TEST_EQ(sizeof(little_uint32_buf_t), 4u);
+    BOOST_TEST_EQ(sizeof(little_uint40_buf_t), 5u);
+    BOOST_TEST_EQ(sizeof(little_uint48_buf_t), 6u);
+    BOOST_TEST_EQ(sizeof(little_uint56_buf_t), 7u);
     BOOST_TEST_EQ(sizeof(little_uint64_buf_t), 8u);
+
+    BOOST_TEST_EQ(sizeof(native_int8_buf_t), 1u);
+    BOOST_TEST_EQ(sizeof(native_int16_buf_t), 2u);
+    BOOST_TEST_EQ(sizeof(native_int24_buf_t), 3u);
+    BOOST_TEST_EQ(sizeof(native_int32_buf_t), 4u);
+    BOOST_TEST_EQ(sizeof(native_int40_buf_t), 5u);
+    BOOST_TEST_EQ(sizeof(native_int48_buf_t), 6u);
+    BOOST_TEST_EQ(sizeof(native_int56_buf_t), 7u);
+    BOOST_TEST_EQ(sizeof(native_int64_buf_t), 8u);
+
+    BOOST_TEST_EQ(sizeof(native_uint8_buf_t), 1u);
+    BOOST_TEST_EQ(sizeof(native_uint16_buf_t), 2u);
+    BOOST_TEST_EQ(sizeof(native_uint24_buf_t), 3u);
+    BOOST_TEST_EQ(sizeof(native_uint32_buf_t), 4u);
+    BOOST_TEST_EQ(sizeof(native_uint40_buf_t), 5u);
+    BOOST_TEST_EQ(sizeof(native_uint48_buf_t), 6u);
+    BOOST_TEST_EQ(sizeof(native_uint56_buf_t), 7u);
+    BOOST_TEST_EQ(sizeof(native_uint64_buf_t), 8u);
+
+    BOOST_TEST_EQ(sizeof(big_int8_buf_at), 1u);
+    BOOST_TEST_EQ(sizeof(big_int16_buf_at), 2u);
+    BOOST_TEST_EQ(sizeof(big_int32_buf_at), 4u);
+    BOOST_TEST_EQ(sizeof(big_int64_buf_at), 8u);
+
+    BOOST_TEST_EQ(sizeof(big_uint8_buf_at), 1u);
+    BOOST_TEST_EQ(sizeof(big_uint16_buf_at), 2u);
+    BOOST_TEST_EQ(sizeof(big_uint32_buf_at), 4u);
+    BOOST_TEST_EQ(sizeof(big_uint64_buf_at), 8u);
+
+    BOOST_TEST_EQ(sizeof(little_int8_buf_at), 1u);
+    BOOST_TEST_EQ(sizeof(little_int16_buf_at), 2u);
+    BOOST_TEST_EQ(sizeof(little_int32_buf_at), 4u);
+    BOOST_TEST_EQ(sizeof(little_int64_buf_at), 8u);
+
+    BOOST_TEST_EQ(sizeof(little_uint8_buf_at), 1u);
+    BOOST_TEST_EQ(sizeof(little_uint16_buf_at), 2u);
+    BOOST_TEST_EQ(sizeof(little_uint32_buf_at), 4u);
+    BOOST_TEST_EQ(sizeof(little_uint64_buf_at), 8u);
   } // check_size
 
   //  test_inserter_and_extractor  -----------------------------------------------------//
@@ -125,8 +125,8 @@ namespace
   {
     std::cout << "test inserter and extractor..." << std::endl;
 
-    big_uint64_buf_ut bu64(0x010203040506070ULL);
-    little_uint64_buf_ut lu64(0x010203040506070ULL);
+    big_uint64_buf_t bu64(0x010203040506070ULL);
+    little_uint64_buf_t lu64(0x010203040506070ULL);
 
     uint64_t x;
 
@@ -143,13 +143,13 @@ namespace
 
     ss.clear();
     ss << 0x010203040506070ULL;
-    big_uint64_buf_ut bu64z(0);
+    big_uint64_buf_t bu64z(0);
     ss >> bu64z;
     BOOST_TEST_EQ(bu64z.value(), bu64.value());
 
     ss.clear();
     ss << 0x010203040506070ULL;
-    little_uint64_buf_ut lu64z(0);
+    little_uint64_buf_t lu64z(0);
     ss >> lu64z;
     BOOST_TEST_EQ(lu64z.value(), lu64.value());
 
@@ -166,7 +166,7 @@ int cpp_main(int, char *[])
   cout << "byte swap intrinsics: " BOOST_ENDIAN_INTRINSIC_MSG << endl;
 
   cout << "  construct big endian aligned" << endl;
-  big_int32_buf_t x(1122334455);
+  big_int32_buf_at x(1122334455);
 
   cout << "  assign to buffer from built-in integer" << endl;
   x = 1234567890;
@@ -176,7 +176,7 @@ int cpp_main(int, char *[])
   BOOST_TEST(b1);
 
   cout << "  construct little endian unaligned" << endl;
-  little_int32_buf_ut x2(1122334455);
+  little_int32_buf_t x2(1122334455);
 
   cout << "  assign to buffer from built-in integer" << endl;
   x2 = 1234567890;
diff --git a/test/endian_in_union_test.cpp b/test/endian_in_union_test.cpp
index 271c855..d82bb3f 100644
--- a/test/endian_in_union_test.cpp
+++ b/test/endian_in_union_test.cpp
@@ -21,59 +21,59 @@ using namespace boost::endian;
 
 union U
 {
-  big_int8_ut           big_8;
-  big_int16_ut          big_16;
-  big_int24_ut          big_24;
-  big_int32_ut          big_32;
-  big_int40_ut          big_40;
-  big_int48_ut          big_48;
-  big_int56_ut          big_56;
-  big_int64_ut          big_64;
+  big_int8_t           big_8;
+  big_int16_t          big_16;
+  big_int24_t          big_24;
+  big_int32_t          big_32;
+  big_int40_t          big_40;
+  big_int48_t          big_48;
+  big_int56_t          big_56;
+  big_int64_t          big_64;
                    
-  big_uint8_ut          big_u8;
-  big_uint16_ut         big_u16;
-  big_uint24_ut         big_u24;
-  big_uint32_ut         big_u32;
-  big_uint40_ut         big_u40;
-  big_uint48_ut         big_u48;
-  big_uint56_ut         big_u56;
-  big_uint64_ut         big_u64;
+  big_uint8_t          big_u8;
+  big_uint16_t         big_u16;
+  big_uint24_t         big_u24;
+  big_uint32_t         big_u32;
+  big_uint40_t         big_u40;
+  big_uint48_t         big_u48;
+  big_uint56_t         big_u56;
+  big_uint64_t         big_u64;
                    
-  little_int8_ut        little_8;
-  little_int16_ut       little_16;
-  little_int24_ut       little_24;
-  little_int32_ut       little_32;
-  little_int40_ut       little_40;
-  little_int48_ut       little_48;
-  little_int56_ut       little_56;
-  little_int64_ut       little_64;
+  little_int8_t        little_8;
+  little_int16_t       little_16;
+  little_int24_t       little_24;
+  little_int32_t       little_32;
+  little_int40_t       little_40;
+  little_int48_t       little_48;
+  little_int56_t       little_56;
+  little_int64_t       little_64;
                    
-  little_uint8_ut       little_u8;
-  little_uint16_ut      little_u16;
-  little_uint24_ut      little_u24;
-  little_uint32_ut      little_u32;
-  little_uint40_ut      little_u40;
-  little_uint48_ut      little_u48;
-  little_uint56_ut      little_u56;
-  little_uint64_ut      little_u64;
+  little_uint8_t       little_u8;
+  little_uint16_t      little_u16;
+  little_uint24_t      little_u24;
+  little_uint32_t      little_u32;
+  little_uint40_t      little_u40;
+  little_uint48_t      little_u48;
+  little_uint56_t      little_u56;
+  little_uint64_t      little_u64;
                    
-  native_int8_ut        native_8;
-  native_int16_ut       native_16;
-  native_int24_ut       native_24;
-  native_int32_ut       native_32;
-  native_int40_ut       native_40;
-  native_int48_ut       native_48;
-  native_int56_ut       native_56;
-  native_int64_ut       native_64;
+  native_int8_t        native_8;
+  native_int16_t       native_16;
+  native_int24_t       native_24;
+  native_int32_t       native_32;
+  native_int40_t       native_40;
+  native_int48_t       native_48;
+  native_int56_t       native_56;
+  native_int64_t       native_64;
                    
-  native_uint8_ut       native_u8;
-  native_uint16_ut      native_u16;
-  native_uint24_ut      native_u24;
-  native_uint32_ut      native_u32;
-  native_uint40_ut      native_u40;
-  native_uint48_ut      native_u48;
-  native_uint56_ut      native_u56;
-  native_uint64_ut      native_u64;
+  native_uint8_t       native_u8;
+  native_uint16_t      native_u16;
+  native_uint24_t      native_u24;
+  native_uint32_t      native_u32;
+  native_uint40_t      native_u40;
+  native_uint48_t      native_u48;
+  native_uint56_t      native_u56;
+  native_uint64_t      native_u64;
 };
 
 U foo;
diff --git a/test/endian_operations_test.cpp b/test/endian_operations_test.cpp
index caa7088..0ee8fbc 100644
--- a/test/endian_operations_test.cpp
+++ b/test/endian_operations_test.cpp
@@ -194,67 +194,67 @@ void op_test_aux()
   Test::test();
   Test::test();
   Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
   Test::test();
+  Test::test();
   Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
   Test::test();
+  Test::test();
   Test::test();
+  Test::test();
   Test::test();
+  Test::test();
   Test::test();
   Test::test();
+  Test::test();
   Test::test();
   Test::test();
   Test::test();
   Test::test();
+  Test::test();
   Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
 #ifdef BOOST_LONG_ENDIAN_TEST
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
-  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
+  Test::test();
 #endif
 }
 
@@ -272,61 +272,61 @@ void op_test()
   op_test_aux();
   op_test_aux();
   op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
 #ifdef BOOST_LONG_ENDIAN_TEST
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
-  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
+  op_test_aux();
 #endif
 }
 
@@ -336,8 +336,8 @@ void test_inserter_and_extractor()
 {
   std::cout << "test inserter and extractor..." << std::endl;
 
-  be::big_uint64_ut bu64(0x010203040506070ULL);
-  be::little_uint64_ut lu64(0x010203040506070ULL);
+  be::big_uint64_t bu64(0x010203040506070ULL);
+  be::little_uint64_t lu64(0x010203040506070ULL);
 
   uint64_t x;
 
@@ -354,13 +354,13 @@ void test_inserter_and_extractor()
 
   ss.clear();
   ss << 0x010203040506070ULL;
-  be::big_uint64_ut bu64z(0);
+  be::big_uint64_t bu64z(0);
   ss >> bu64z;
   BOOST_TEST_EQ(bu64z, bu64);
 
   ss.clear();
   ss << 0x010203040506070ULL;
-  be::little_uint64_ut lu64z(0);
+  be::little_uint64_t lu64z(0);
   ss >> lu64z;
   BOOST_TEST_EQ(lu64z, lu64);
 
@@ -368,7 +368,7 @@ void test_inserter_and_extractor()
 
 }
 
-void f_big_int32_ut(be::big_int32_ut) {}
+void f_big_int32_ut(be::big_int32_t) {}
 
 //  main  ------------------------------------------------------------------------------//
 
@@ -378,10 +378,10 @@ int cpp_main(int, char * [])
 
   //  make sure some simple things work
 
-  be::big_int32_ut o1(1);
-  be::big_int32_ut o2(2L);
-  be::big_int32_ut o3(3LL);
-  be::big_int64_ut o4(1);
+  be::big_int32_t o1(1);
+  be::big_int32_t o2(2L);
+  be::big_int32_t o3(3LL);
+  be::big_int64_t o4(1);
 
   //  use cases; if BOOST_ENDIAN_LOG is defined, will output to clog info on
   //  what overloads and conversions are actually being performed.
@@ -389,13 +389,13 @@ int cpp_main(int, char * [])
   be::endian_log = true;
 
   std::clog << "set up test values\n";
-  be::big_int32_ut      big(12345);
-  be::little_uint16_ut  little_u(10);
-  be::big_int64_ut      result;
+  be::big_int32_t      big(12345);
+  be::little_uint16_t  little_u(10);
+  be::big_int64_t      result;
 
   // this is the use case that is so irritating that it caused the endian
   // constructors to be made non-explicit
-  std::clog << "\nf(1234) where f(big_int32_ut)\n";
+  std::clog << "\nf(1234) where f(big_int32_t)\n";
   f_big_int32_ut(1234);
 
   std::clog << "\nresult = big\n";
@@ -456,8 +456,8 @@ int cpp_main(int, char * [])
   //  test from Roland Schwarz that detected ambiguities; these ambiguities
   //  were eliminated by BOOST_ENDIAN_MINIMAL_COVER_OPERATORS
   unsigned u;
-  be::little_uint32_ut u1;
-  be::little_uint32_ut u2;
+  be::little_uint32_t u1;
+  be::little_uint32_t u2;
 
   u = 9;
   u1 = 1;
@@ -467,7 +467,7 @@ int cpp_main(int, char * [])
 
   // variations to detect ambiguities
 
-  be::little_uint32_ut u3 = u1 + 5;
+  be::little_uint32_t u3 = u1 + 5;
   u3 = u1 + 5u;
 
   if (u1 == 5)
@@ -482,7 +482,7 @@ int cpp_main(int, char * [])
   u2 = u1 + 5u;
 
   //  one more wrinkle
-  be::little_uint16_ut u4(3);
+  be::little_uint16_t u4(3);
   u4 = 3;
   std::clog << "\nu2 = u1 + u4\n";
   u2 = u1 + u4;
diff --git a/test/endian_test.cpp b/test/endian_test.cpp
index 9687773..d78a061 100644
--- a/test/endian_test.cpp
+++ b/test/endian_test.cpp
@@ -153,82 +153,82 @@ namespace
 
   void check_data()
   {
-    big_int8_ut big_8;
-    big_int16_ut big_16;
-    big_int24_ut big_24;
-    big_int32_ut big_32;
-    big_int40_ut big_40;
-    big_int48_ut big_48;
-    big_int56_ut big_56;
-    big_int64_ut big_64;
+    big_int8_t big_8;
+    big_int16_t big_16;
+    big_int24_t big_24;
+    big_int32_t big_32;
+    big_int40_t big_40;
+    big_int48_t big_48;
+    big_int56_t big_56;
+    big_int64_t big_64;
 
-    big_uint8_ut big_u8;
-    big_uint16_ut big_u16;
-    big_uint24_ut big_u24;
-    big_uint32_ut big_u32;
-    big_uint40_ut big_u40;
-    big_uint48_ut big_u48;
-    big_uint56_ut big_u56;
-    big_uint64_ut big_u64;
+    big_uint8_t big_u8;
+    big_uint16_t big_u16;
+    big_uint24_t big_u24;
+    big_uint32_t big_u32;
+    big_uint40_t big_u40;
+    big_uint48_t big_u48;
+    big_uint56_t big_u56;
+    big_uint64_t big_u64;
 
-    little_int8_ut little_8;
-    little_int16_ut little_16;
-    little_int24_ut little_24;
-    little_int32_ut little_32;
-    little_int40_ut little_40;
-    little_int48_ut little_48;
-    little_int56_ut little_56;
-    little_int64_ut little_64;
+    little_int8_t little_8;
+    little_int16_t little_16;
+    little_int24_t little_24;
+    little_int32_t little_32;
+    little_int40_t little_40;
+    little_int48_t little_48;
+    little_int56_t little_56;
+    little_int64_t little_64;
 
-    little_uint8_ut little_u8;
-    little_uint16_ut little_u16;
-    little_uint24_ut little_u24;
-    little_uint32_ut little_u32;
-    little_uint40_ut little_u40;
-    little_uint48_ut little_u48;
-    little_uint56_ut little_u56;
-    little_uint64_ut little_u64;
+    little_uint8_t little_u8;
+    little_uint16_t little_u16;
+    little_uint24_t little_u24;
+    little_uint32_t little_u32;
+    little_uint40_t little_u40;
+    little_uint48_t little_u48;
+    little_uint56_t little_u56;
+    little_uint64_t little_u64;
 
-    native_int8_ut native_8;
-    native_int16_ut native_16;
-    native_int24_ut native_24;
-    native_int32_ut native_32;
-    native_int40_ut native_40;
-    native_int48_ut native_48;
-    native_int56_ut native_56;
-    native_int64_ut native_64;
+    native_int8_t native_8;
+    native_int16_t native_16;
+    native_int24_t native_24;
+    native_int32_t native_32;
+    native_int40_t native_40;
+    native_int48_t native_48;
+    native_int56_t native_56;
+    native_int64_t native_64;
 
-    native_uint8_ut native_u8;
-    native_uint16_ut native_u16;
-    native_uint24_ut native_u24;
-    native_uint32_ut native_u32;
-    native_uint40_ut native_u40;
-    native_uint48_ut native_u48;
-    native_uint56_ut native_u56;
-    native_uint64_ut native_u64;
+    native_uint8_t native_u8;
+    native_uint16_t native_u16;
+    native_uint24_t native_u24;
+    native_uint32_t native_u32;
+    native_uint40_t native_u40;
+    native_uint48_t native_u48;
+    native_uint56_t native_u56;
+    native_uint64_t native_u64;
 
-    big_int16_t  big_align_int16;
-    big_int32_t  big_align_int32;
-    big_int64_t  big_align_int64;
+    big_int16_at  big_align_int16;
+    big_int32_at  big_align_int32;
+    big_int64_at  big_align_int64;
 
-    big_uint16_t big_align_uint16;
-    big_uint32_t big_align_uint32;
-    big_uint64_t big_align_uint64;
+    big_uint16_at big_align_uint16;
+    big_uint32_at big_align_uint32;
+    big_uint64_at big_align_uint64;
 
-    little_int16_t  little_align_int16;
-    little_int32_t  little_align_int32;
-    little_int64_t  little_align_int64;
+    little_int16_at  little_align_int16;
+    little_int32_at  little_align_int32;
+    little_int64_at  little_align_int64;
 
-    little_uint16_t little_align_uint16;
-    little_uint32_t little_align_uint32;
-    little_uint64_t little_align_uint64;
+    little_uint16_at little_align_uint16;
+    little_uint32_at little_align_uint32;
+    little_uint64_at little_align_uint64;
 
-    big_float32_t big_align_float32;
-    big_float64_t big_align_float64;
-    little_float32_t little_align_float32;
-    little_float64_t little_align_float64;
-    native_float32_t native_align_float32;
-    native_float64_t native_align_float64;
+    big_float32_at big_align_float32;
+    big_float64_at big_align_float64;
+    little_float32_at little_align_float32;
+    little_float64_at little_align_float64;
+    native_float32_at native_align_float32;
+    native_float64_at native_align_float64;
 
     VERIFY(big_align_float32.data() == reinterpret_cast(&big_align_float32));
     VERIFY(big_align_float64.data() == reinterpret_cast(&big_align_float64));
@@ -239,12 +239,12 @@ namespace
     VERIFY(native_align_float32.data() == reinterpret_cast(&native_align_float32));
     VERIFY(native_align_float64.data() == reinterpret_cast(&native_align_float64));
 
-    big_float32_ut big_float32;
-    big_float64_ut big_float64;
-    little_float32_ut little_float32;
-    little_float64_ut little_float64;
-    native_float32_ut native_float32;
-    native_float64_ut native_float64;
+    big_float32_t big_float32;
+    big_float64_t big_float64;
+    little_float32_t little_float32;
+    little_float64_t little_float64;
+    native_float32_t native_float32;
+    native_float64_t native_float64;
 
     VERIFY(big_float32.data() == reinterpret_cast(&big_float32));
     VERIFY(big_float64.data() == reinterpret_cast(&big_float64));
@@ -334,6 +334,13 @@ namespace
     VERIFY( numeric_limits::digits == 7 );
     VERIFY( numeric_limits::digits == 8 );
 
+    VERIFY_SIZE(sizeof( big_float32_at ), 4 );
+    VERIFY_SIZE(sizeof( big_float64_at ), 8 );
+    VERIFY_SIZE(sizeof(little_float32_at), 4);
+    VERIFY_SIZE(sizeof(little_float64_at), 8);
+    VERIFY_SIZE(sizeof(native_float32_at), 4);
+    VERIFY_SIZE(sizeof(native_float64_at), 8);
+
     VERIFY_SIZE(sizeof( big_float32_t ), 4 );
     VERIFY_SIZE(sizeof( big_float64_t ), 8 );
     VERIFY_SIZE(sizeof(little_float32_t), 4);
@@ -341,86 +348,79 @@ namespace
     VERIFY_SIZE(sizeof(native_float32_t), 4);
     VERIFY_SIZE(sizeof(native_float64_t), 8);
 
-    VERIFY_SIZE(sizeof( big_float32_ut ), 4 );
-    VERIFY_SIZE(sizeof( big_float64_ut ), 8 );
-    VERIFY_SIZE(sizeof(little_float32_ut), 4);
-    VERIFY_SIZE(sizeof(little_float64_ut), 8);
-    VERIFY_SIZE(sizeof(native_float32_ut), 4);
-    VERIFY_SIZE(sizeof(native_float64_ut), 8);
-
-    VERIFY_SIZE( sizeof( big_int8_ut ), 1 );
-    VERIFY_SIZE( sizeof( big_int16_ut ), 2 );
-    VERIFY_SIZE( sizeof( big_int24_ut ), 3 );
-    VERIFY_SIZE( sizeof( big_int32_ut ), 4 );
-    VERIFY_SIZE( sizeof( big_int40_ut ), 5 );
-    VERIFY_SIZE( sizeof( big_int48_ut ), 6 );
-    VERIFY_SIZE( sizeof( big_int56_ut ), 7 );
-    VERIFY_SIZE( sizeof( big_int64_ut ), 8 );
-
-    VERIFY_SIZE( sizeof( big_uint8_ut ), 1 );
-    VERIFY_SIZE( sizeof( big_uint16_ut ), 2 );
-    VERIFY_SIZE( sizeof( big_uint24_ut ), 3 );
-    VERIFY_SIZE( sizeof( big_uint32_ut ), 4 );
-    VERIFY_SIZE( sizeof( big_uint40_ut ), 5 );
-    VERIFY_SIZE( sizeof( big_uint48_ut ), 6 );
-    VERIFY_SIZE( sizeof( big_uint56_ut ), 7 );
-    VERIFY_SIZE( sizeof( big_uint64_ut ), 8 );
-
-    VERIFY_SIZE( sizeof( little_int8_ut ), 1 );
-    VERIFY_SIZE( sizeof( little_int16_ut ), 2 );
-    VERIFY_SIZE( sizeof( little_int24_ut ), 3 );
-    VERIFY_SIZE( sizeof( little_int32_ut ), 4 );
-    VERIFY_SIZE( sizeof( little_int40_ut ), 5 );
-    VERIFY_SIZE( sizeof( little_int48_ut ), 6 );
-    VERIFY_SIZE( sizeof( little_int56_ut ), 7 );
-    VERIFY_SIZE( sizeof( little_int64_ut ), 8 );
-
-    VERIFY_SIZE( sizeof( little_uint8_ut ), 1 );
-    VERIFY_SIZE( sizeof( little_uint16_ut ), 2 );
-    VERIFY_SIZE( sizeof( little_uint24_ut ), 3 );
-    VERIFY_SIZE( sizeof( little_uint32_ut ), 4 );
-    VERIFY_SIZE( sizeof( little_uint40_ut ), 5 );
-    VERIFY_SIZE( sizeof( little_uint48_ut ), 6 );
-    VERIFY_SIZE( sizeof( little_uint56_ut ), 7 );
-    VERIFY_SIZE( sizeof( little_uint64_ut ), 8 );
-
-    VERIFY_SIZE( sizeof( native_int8_ut ), 1 );
-    VERIFY_SIZE( sizeof( native_int16_ut ), 2 );
-    VERIFY_SIZE( sizeof( native_int24_ut ), 3 );
-    VERIFY_SIZE( sizeof( native_int32_ut ), 4 );
-    VERIFY_SIZE( sizeof( native_int40_ut ), 5 );
-    VERIFY_SIZE( sizeof( native_int48_ut ), 6 );
-    VERIFY_SIZE( sizeof( native_int56_ut ), 7 );
-    VERIFY_SIZE( sizeof( native_int64_ut ), 8 );
-
-    VERIFY_SIZE( sizeof( native_uint8_ut ), 1 );
-    VERIFY_SIZE( sizeof( native_uint16_ut ), 2 );
-    VERIFY_SIZE( sizeof( native_uint24_ut ), 3 );
-    VERIFY_SIZE( sizeof( native_uint32_ut ), 4 );
-    VERIFY_SIZE( sizeof( native_uint40_ut ), 5 );
-    VERIFY_SIZE( sizeof( native_uint48_ut ), 6 );
-    VERIFY_SIZE( sizeof( native_uint56_ut ), 7 );
-    VERIFY_SIZE( sizeof( native_uint64_ut ), 8 );
-
-    VERIFY_SIZE(sizeof(big_int8_t), 1);
-    VERIFY_SIZE(sizeof(big_int16_t), 2);
+    VERIFY_SIZE( sizeof( big_int8_t ), 1 );
+    VERIFY_SIZE( sizeof( big_int16_t ), 2 );
+    VERIFY_SIZE( sizeof( big_int24_t ), 3 );
     VERIFY_SIZE( sizeof( big_int32_t ), 4 );
+    VERIFY_SIZE( sizeof( big_int40_t ), 5 );
+    VERIFY_SIZE( sizeof( big_int48_t ), 6 );
+    VERIFY_SIZE( sizeof( big_int56_t ), 7 );
     VERIFY_SIZE( sizeof( big_int64_t ), 8 );
 
-    VERIFY_SIZE(sizeof(big_uint8_t), 1);
-    VERIFY_SIZE(sizeof(big_uint16_t), 2);
+    VERIFY_SIZE( sizeof( big_uint8_t ), 1 );
+    VERIFY_SIZE( sizeof( big_uint16_t ), 2 );
+    VERIFY_SIZE( sizeof( big_uint24_t ), 3 );
     VERIFY_SIZE( sizeof( big_uint32_t ), 4 );
+    VERIFY_SIZE( sizeof( big_uint40_t ), 5 );
+    VERIFY_SIZE( sizeof( big_uint48_t ), 6 );
+    VERIFY_SIZE( sizeof( big_uint56_t ), 7 );
     VERIFY_SIZE( sizeof( big_uint64_t ), 8 );
 
-    VERIFY_SIZE(sizeof(little_int8_t), 1);
-    VERIFY_SIZE(sizeof(little_int16_t), 2);
+    VERIFY_SIZE( sizeof( little_int8_t ), 1 );
+    VERIFY_SIZE( sizeof( little_int16_t ), 2 );
+    VERIFY_SIZE( sizeof( little_int24_t ), 3 );
     VERIFY_SIZE( sizeof( little_int32_t ), 4 );
+    VERIFY_SIZE( sizeof( little_int40_t ), 5 );
+    VERIFY_SIZE( sizeof( little_int48_t ), 6 );
+    VERIFY_SIZE( sizeof( little_int56_t ), 7 );
     VERIFY_SIZE( sizeof( little_int64_t ), 8 );
 
-    VERIFY_SIZE(sizeof(little_uint8_t), 1);
-    VERIFY_SIZE(sizeof(little_uint16_t), 2);
+    VERIFY_SIZE( sizeof( little_uint8_t ), 1 );
+    VERIFY_SIZE( sizeof( little_uint16_t ), 2 );
+    VERIFY_SIZE( sizeof( little_uint24_t ), 3 );
     VERIFY_SIZE( sizeof( little_uint32_t ), 4 );
+    VERIFY_SIZE( sizeof( little_uint40_t ), 5 );
+    VERIFY_SIZE( sizeof( little_uint48_t ), 6 );
+    VERIFY_SIZE( sizeof( little_uint56_t ), 7 );
     VERIFY_SIZE( sizeof( little_uint64_t ), 8 );
+
+    VERIFY_SIZE( sizeof( native_int8_t ), 1 );
+    VERIFY_SIZE( sizeof( native_int16_t ), 2 );
+    VERIFY_SIZE( sizeof( native_int24_t ), 3 );
+    VERIFY_SIZE( sizeof( native_int32_t ), 4 );
+    VERIFY_SIZE( sizeof( native_int40_t ), 5 );
+    VERIFY_SIZE( sizeof( native_int48_t ), 6 );
+    VERIFY_SIZE( sizeof( native_int56_t ), 7 );
+    VERIFY_SIZE( sizeof( native_int64_t ), 8 );
+
+    VERIFY_SIZE( sizeof( native_uint8_t ), 1 );
+    VERIFY_SIZE( sizeof( native_uint16_t ), 2 );
+    VERIFY_SIZE( sizeof( native_uint24_t ), 3 );
+    VERIFY_SIZE( sizeof( native_uint32_t ), 4 );
+    VERIFY_SIZE( sizeof( native_uint40_t ), 5 );
+    VERIFY_SIZE( sizeof( native_uint48_t ), 6 );
+    VERIFY_SIZE( sizeof( native_uint56_t ), 7 );
+    VERIFY_SIZE( sizeof( native_uint64_t ), 8 );
+
+    VERIFY_SIZE(sizeof(big_int8_at), 1);
+    VERIFY_SIZE(sizeof(big_int16_at), 2);
+    VERIFY_SIZE( sizeof( big_int32_at ), 4 );
+    VERIFY_SIZE( sizeof( big_int64_at ), 8 );
+
+    VERIFY_SIZE(sizeof(big_uint8_at), 1);
+    VERIFY_SIZE(sizeof(big_uint16_at), 2);
+    VERIFY_SIZE( sizeof( big_uint32_at ), 4 );
+    VERIFY_SIZE( sizeof( big_uint64_at ), 8 );
+
+    VERIFY_SIZE(sizeof(little_int8_at), 1);
+    VERIFY_SIZE(sizeof(little_int16_at), 2);
+    VERIFY_SIZE( sizeof( little_int32_at ), 4 );
+    VERIFY_SIZE( sizeof( little_int64_at ), 8 );
+
+    VERIFY_SIZE(sizeof(little_uint8_at), 1);
+    VERIFY_SIZE(sizeof(little_uint16_at), 2);
+    VERIFY_SIZE( sizeof( little_uint32_at ), 4 );
+    VERIFY_SIZE( sizeof( little_uint64_at ), 8 );
   } // check_size
 
   //  check_alignment  -------------------------------------------------------//
@@ -432,148 +432,148 @@ namespace
 
     struct big_struct
     {
-      big_int8_ut    v0;
-      big_int16_ut    v1;
-      big_int24_ut    v3;
+      big_int8_t    v0;
+      big_int16_t    v1;
+      big_int24_t    v3;
       char      v6;
-      big_int32_ut    v7;
-      big_int40_ut    v11;
+      big_int32_t    v7;
+      big_int40_t    v11;
       char      v16;
-      big_int48_ut    v17;
-      big_int56_ut    v23;
+      big_int48_t    v17;
+      big_int56_t    v23;
       char      v30;
-      big_int64_ut    v31;
+      big_int64_t    v31;
     };
 
     struct big_u_struct
     {
-      big_uint8_ut    v0;
-      big_uint16_ut    v1;
-      big_uint24_ut    v3;
+      big_uint8_t    v0;
+      big_uint16_t    v1;
+      big_uint24_t    v3;
       char       v6;
-      big_uint32_ut    v7;
-      big_uint40_ut    v11;
+      big_uint32_t    v7;
+      big_uint40_t    v11;
       char       v16;
-      big_uint48_ut    v17;
-      big_uint56_ut    v23;
+      big_uint48_t    v17;
+      big_uint56_t    v23;
       char       v30;
-      big_uint64_ut    v31;
+      big_uint64_t    v31;
     };
 
     struct little_struct
     {
-      little_int8_ut    v0;
-      little_int16_ut    v1;
-      little_int24_ut    v3;
+      little_int8_t    v0;
+      little_int16_t    v1;
+      little_int24_t    v3;
       char         v6;
-      little_int32_ut    v7;
-      little_int40_ut    v11;
+      little_int32_t    v7;
+      little_int40_t    v11;
       char         v16;
-      little_int48_ut    v17;
-      little_int56_ut    v23;
+      little_int48_t    v17;
+      little_int56_t    v23;
       char         v30;
-      little_int64_ut    v31;
+      little_int64_t    v31;
     };
 
     struct little_u_struct
     {
-      little_uint8_ut    v0;
-      little_uint16_ut    v1;
-      little_uint24_ut    v3;
+      little_uint8_t    v0;
+      little_uint16_t    v1;
+      little_uint24_t    v3;
       char          v6;
-      little_uint32_ut    v7;
-      little_uint40_ut    v11;
+      little_uint32_t    v7;
+      little_uint40_t    v11;
       char          v16;
-      little_uint48_ut    v17;
-      little_uint56_ut    v23;
+      little_uint48_t    v17;
+      little_uint56_t    v23;
       char          v30;
-      little_uint64_ut    v31;
+      little_uint64_t    v31;
     };
 
     struct native_struct
     {
-      native_int8_ut    v0;
-      native_int16_ut    v1;
-      native_int24_ut    v3;
+      native_int8_t    v0;
+      native_int16_t    v1;
+      native_int24_t    v3;
       char         v6;
-      native_int32_ut    v7;
-      native_int40_ut    v11;
+      native_int32_t    v7;
+      native_int40_t    v11;
       char         v16;
-      native_int48_ut    v17;
-      native_int56_ut    v23;
+      native_int48_t    v17;
+      native_int56_t    v23;
       char         v30;
-      native_int64_ut    v31;
+      native_int64_t    v31;
     };
 
     struct native_u_struct
     {
-      native_uint8_ut    v0;
-      native_uint16_ut    v1;
-      native_uint24_ut    v3;
+      native_uint8_t    v0;
+      native_uint16_t    v1;
+      native_uint24_t    v3;
       char          v6;
-      native_uint32_ut    v7;
-      native_uint40_ut    v11;
+      native_uint32_t    v7;
+      native_uint40_t    v11;
       char          v16;
-      native_uint48_ut    v17;
-      native_uint56_ut    v23;
+      native_uint48_t    v17;
+      native_uint56_t    v23;
       char          v30;
-      native_uint64_ut    v31;
+      native_uint64_t    v31;
     };
 
     struct big_float_struct
     {
       int16_t v0;
-      big_float32_t v1;
+      big_float32_at v1;
     };
 
     struct big_unaligned_float_struct
     {
       int16_t v0;
-      big_float32_ut v1;
+      big_float32_t v1;
     };
 
     struct little_float_struct
     {
       int16_t v0;
-      little_float32_t v1;
+      little_float32_at v1;
     };
 
     struct little_unaligned_float_struct
     {
       int16_t v0;
-      little_float32_ut v1;
+      little_float32_t v1;
     };
 
     struct native_float_struct
     {
       int16_t v0;
-      native_float32_t v1;
+      native_float32_at v1;
     };
 
     struct native_unaligned_float_struct
     {
       int16_t v0;
-      native_float32_ut v1;
+      native_float32_t v1;
     };
 
     //  aligned test cases
   
     struct big_aligned_struct
     {
-      big_int16_t    v0;
-      big_int32_t    v1;
+      big_int16_at    v0;
+      big_int32_at    v1;
       char          v3;
       // on a 32-bit system, the padding here may be 3 rather than 7 bytes
-      big_int64_t    v4;
+      big_int64_at    v4;
     };
   
     struct little_aligned_struct
     {
-      little_int16_t    v0;
-      little_int32_t    v1;
+      little_int16_at    v0;
+      little_int32_at    v1;
       char          v3;
       // on a 32-bit system, the padding here may be 3 rather than 7 bytes
-      little_int64_t    v4;
+      little_int64_at    v4;
     };
 
     int saved_err_count = err_count;
@@ -607,295 +607,295 @@ namespace
     // aligned floating point types
     float big_float32_expected = (std::numeric_limits::max) ();
     boost::endian::native_to_big_inplace(big_float32_expected);
-    big_float32_t big_float32((std::numeric_limits::max) ());
+    big_float32_at big_float32((std::numeric_limits::max) ());
     VERIFY(std::memcmp(big_float32.data(),
       reinterpret_cast(&big_float32_expected), sizeof(float)) == 0);
 
     float little_float32_expected = (std::numeric_limits::max) ();
     boost::endian::native_to_little_inplace(little_float32_expected);
-    little_float32_t little_float32((std::numeric_limits::max) ());
+    little_float32_at little_float32((std::numeric_limits::max) ());
     VERIFY(std::memcmp(little_float32.data(),
       reinterpret_cast(&little_float32_expected), sizeof(float)) == 0);
 
     double big_float64_expected = (std::numeric_limits::max) ();
     boost::endian::native_to_big_inplace(big_float64_expected);
-    big_float64_t big_float64((std::numeric_limits::max) ());
+    big_float64_at big_float64((std::numeric_limits::max) ());
     VERIFY(std::memcmp(big_float64.data(),
       reinterpret_cast(&big_float64_expected), sizeof(double)) == 0);
 
     double little_float64_expected = (std::numeric_limits::max) ();
     boost::endian::native_to_little_inplace(little_float64_expected);
-    little_float64_t little_float64((std::numeric_limits::max) ());
+    little_float64_at little_float64((std::numeric_limits::max) ());
     VERIFY(std::memcmp(little_float64.data(),
       reinterpret_cast(&little_float64_expected), sizeof(double)) == 0);
 
-    VERIFY_VALUE_AND_OPS( big_float32_t, float,  (std::numeric_limits::max) () );
-    VERIFY_VALUE_AND_OPS( big_float32_t, float, (std::numeric_limits::min) () );
-    VERIFY_VALUE_AND_OPS( big_float64_t, double,  (std::numeric_limits::max) () );
-    VERIFY_VALUE_AND_OPS( big_float64_t, double, (std::numeric_limits::min) () );
+    VERIFY_VALUE_AND_OPS( big_float32_at, float,  (std::numeric_limits::max) () );
+    VERIFY_VALUE_AND_OPS( big_float32_at, float, (std::numeric_limits::min) () );
+    VERIFY_VALUE_AND_OPS( big_float64_at, double,  (std::numeric_limits::max) () );
+    VERIFY_VALUE_AND_OPS( big_float64_at, double, (std::numeric_limits::min) () );
 
-    VERIFY_VALUE_AND_OPS( little_float32_t, float,  (std::numeric_limits::max) () );
-    VERIFY_VALUE_AND_OPS( little_float32_t, float, (std::numeric_limits::min) () );
-    VERIFY_VALUE_AND_OPS( little_float64_t, double,  (std::numeric_limits::max) () );
-    VERIFY_VALUE_AND_OPS( little_float64_t, double, (std::numeric_limits::min) () );
+    VERIFY_VALUE_AND_OPS( little_float32_at, float,  (std::numeric_limits::max) () );
+    VERIFY_VALUE_AND_OPS( little_float32_at, float, (std::numeric_limits::min) () );
+    VERIFY_VALUE_AND_OPS( little_float64_at, double,  (std::numeric_limits::max) () );
+    VERIFY_VALUE_AND_OPS( little_float64_at, double, (std::numeric_limits::min) () );
 
     // unaligned floating point types
     float big_float32un_expected = (std::numeric_limits::max) ();
     boost::endian::native_to_big_inplace(big_float32un_expected);
-    big_float32_ut big_float32un((std::numeric_limits::max) ());
+    big_float32_t big_float32un((std::numeric_limits::max) ());
     VERIFY(std::memcmp(big_float32un.data(),
       reinterpret_cast(&big_float32un_expected), sizeof(float)) == 0);
 
     float little_float32un_expected = (std::numeric_limits::max) ();
     boost::endian::native_to_little_inplace(little_float32un_expected);
-    little_float32_ut little_float32un((std::numeric_limits::max) ());
+    little_float32_t little_float32un((std::numeric_limits::max) ());
     VERIFY(std::memcmp(little_float32un.data(),
       reinterpret_cast(&little_float32un_expected), sizeof(float)) == 0);
 
     double big_float64un_expected = (std::numeric_limits::max) ();
     boost::endian::native_to_big_inplace(big_float64un_expected);
-    big_float64_ut big_float64un((std::numeric_limits::max) ());
+    big_float64_t big_float64un((std::numeric_limits::max) ());
     VERIFY(std::memcmp(big_float64un.data(),
       reinterpret_cast(&big_float64un_expected), sizeof(double)) == 0);
 
     double little_float64un_expected = (std::numeric_limits::max) ();
     boost::endian::native_to_little_inplace(little_float64un_expected);
-    little_float64_ut little_float64un((std::numeric_limits::max) ());
+    little_float64_t little_float64un((std::numeric_limits::max) ());
     VERIFY(std::memcmp(little_float64un.data(),
       reinterpret_cast(&little_float64un_expected), sizeof(double)) == 0);
 
-    VERIFY_VALUE_AND_OPS( big_float32_ut, float, (std::numeric_limits::max) () );
-    VERIFY_VALUE_AND_OPS( big_float32_ut, float, (std::numeric_limits::min) () );
-    VERIFY_VALUE_AND_OPS( big_float64_ut, double, (std::numeric_limits::max) () );
-    VERIFY_VALUE_AND_OPS( big_float64_ut, double, (std::numeric_limits::min) () );
+    VERIFY_VALUE_AND_OPS( big_float32_t, float, (std::numeric_limits::max) () );
+    VERIFY_VALUE_AND_OPS( big_float32_t, float, (std::numeric_limits::min) () );
+    VERIFY_VALUE_AND_OPS( big_float64_t, double, (std::numeric_limits::max) () );
+    VERIFY_VALUE_AND_OPS( big_float64_t, double, (std::numeric_limits::min) () );
 
-    VERIFY_VALUE_AND_OPS( little_float32_ut, float, (std::numeric_limits::max) () );
-    VERIFY_VALUE_AND_OPS( little_float32_ut, float, (std::numeric_limits::min) () );
-    VERIFY_VALUE_AND_OPS( little_float64_ut, double, (std::numeric_limits::max) () );
-    VERIFY_VALUE_AND_OPS( little_float64_ut, double, (std::numeric_limits::min) () );
+    VERIFY_VALUE_AND_OPS( little_float32_t, float, (std::numeric_limits::max) () );
+    VERIFY_VALUE_AND_OPS( little_float32_t, float, (std::numeric_limits::min) () );
+    VERIFY_VALUE_AND_OPS( little_float64_t, double, (std::numeric_limits::max) () );
+    VERIFY_VALUE_AND_OPS( little_float64_t, double, (std::numeric_limits::min) () );
 
     float a = 1.0F;
-    big_float32_t b(1.0F);
-    big_float32_ut c(1.0F);
-    little_float32_t d(1.0F);
-    little_float32_ut e(1.0F);
+    big_float32_at b(1.0F);
+    big_float32_t c(1.0F);
+    little_float32_at d(1.0F);
+    little_float32_t e(1.0F);
     VERIFY(a==b);
     VERIFY(a==c);
     VERIFY(a==d);
     VERIFY(a==e);
 
     // unaligned integer types
-    VERIFY_BIG_REPRESENTATION( big_int8_ut );
-    VERIFY_VALUE_AND_OPS( big_int8_ut, int_least8_t,  0x7f );
-    VERIFY_VALUE_AND_OPS( big_int8_ut, int_least8_t, -0x80 );
+    VERIFY_BIG_REPRESENTATION( big_int8_t );
+    VERIFY_VALUE_AND_OPS( big_int8_t, int_least8_t,  0x7f );
+    VERIFY_VALUE_AND_OPS( big_int8_t, int_least8_t, -0x80 );
 
-    VERIFY_BIG_REPRESENTATION( big_int16_ut );
-    VERIFY_VALUE_AND_OPS( big_int16_ut, int_least16_t,  0x7fff );
-    VERIFY_VALUE_AND_OPS( big_int16_ut, int_least16_t, -0x8000 );
-
-    VERIFY_BIG_REPRESENTATION( big_int24_ut );
-    VERIFY_VALUE_AND_OPS( big_int24_ut, int_least32_t,  0x7fffff );
-    VERIFY_VALUE_AND_OPS( big_int24_ut, int_least32_t, -0x800000 );
-
-    VERIFY_BIG_REPRESENTATION( big_int32_ut );
-    VERIFY_VALUE_AND_OPS( big_int32_ut, int_least32_t,  0x7fffffff );
-    VERIFY_VALUE_AND_OPS( big_int32_ut, int_least32_t, -0x7fffffff-1 );
-
-    VERIFY_BIG_REPRESENTATION( big_int40_ut );
-    VERIFY_VALUE_AND_OPS( big_int40_ut, int_least64_t,  0x7fffffffffLL );
-    VERIFY_VALUE_AND_OPS( big_int40_ut, int_least64_t, -0x8000000000LL );
-
-    VERIFY_BIG_REPRESENTATION( big_int48_ut );
-    VERIFY_VALUE_AND_OPS( big_int48_ut, int_least64_t,  0x7fffffffffffLL );
-    VERIFY_VALUE_AND_OPS( big_int48_ut, int_least64_t, -0x800000000000LL );
-
-    VERIFY_BIG_REPRESENTATION( big_int56_ut );
-    VERIFY_VALUE_AND_OPS( big_int56_ut, int_least64_t,  0x7fffffffffffffLL );
-    VERIFY_VALUE_AND_OPS( big_int56_ut, int_least64_t, -0x80000000000000LL );
-
-    VERIFY_BIG_REPRESENTATION( big_int64_ut );
-    VERIFY_VALUE_AND_OPS( big_int64_ut, int_least64_t,  0x7fffffffffffffffLL );
-    VERIFY_VALUE_AND_OPS( big_int64_ut, int_least64_t, -0x7fffffffffffffffLL-1 );
-
-    VERIFY_BIG_REPRESENTATION( big_uint8_ut );
-    VERIFY_VALUE_AND_OPS( big_uint8_ut, uint_least8_t,  0xff );
-
-    VERIFY_BIG_REPRESENTATION( big_uint16_ut );
-    VERIFY_VALUE_AND_OPS( big_uint16_ut, uint_least16_t, 0xffff );
-
-    VERIFY_BIG_REPRESENTATION( big_uint24_ut );
-    VERIFY_VALUE_AND_OPS( big_uint24_ut, uint_least32_t, 0xffffff );
-
-    VERIFY_BIG_REPRESENTATION( big_uint32_ut );
-    VERIFY_VALUE_AND_OPS( big_uint32_ut, uint_least32_t, 0xffffffff );
-
-    VERIFY_BIG_REPRESENTATION( big_uint40_ut );
-    VERIFY_VALUE_AND_OPS( big_uint40_ut, uint_least64_t, 0xffffffffffLL );
-
-    VERIFY_BIG_REPRESENTATION( big_uint48_ut );
-    VERIFY_VALUE_AND_OPS( big_uint48_ut, uint_least64_t, 0xffffffffffffLL );
-
-    VERIFY_BIG_REPRESENTATION( big_uint56_ut );
-    VERIFY_VALUE_AND_OPS( big_uint56_ut, uint_least64_t, 0xffffffffffffffLL );
-
-    VERIFY_BIG_REPRESENTATION( big_uint64_ut );
-    VERIFY_VALUE_AND_OPS( big_uint64_ut, uint_least64_t, 0xffffffffffffffffULL );
-
-    VERIFY_LITTLE_REPRESENTATION( little_int8_ut );
-    VERIFY_VALUE_AND_OPS( little_int8_ut, int_least8_t,   0x7f );
-    VERIFY_VALUE_AND_OPS( little_int8_ut, int_least8_t,  -0x80 );
-
-    VERIFY_LITTLE_REPRESENTATION( little_int16_ut );
-    VERIFY_VALUE_AND_OPS( little_int16_ut, int_least16_t,  0x7fff );
-    VERIFY_VALUE_AND_OPS( little_int16_ut, int_least16_t, -0x8000 );
-
-    VERIFY_LITTLE_REPRESENTATION( little_int24_ut );
-    VERIFY_VALUE_AND_OPS( little_int24_ut, int_least32_t,  0x7fffff );
-    VERIFY_VALUE_AND_OPS( little_int24_ut, int_least32_t, -0x800000 );
-
-    VERIFY_LITTLE_REPRESENTATION( little_int32_ut );
-    VERIFY_VALUE_AND_OPS( little_int32_ut, int_least32_t,  0x7fffffff );
-    VERIFY_VALUE_AND_OPS( little_int32_ut, int_least32_t, -0x7fffffff-1 );
-
-    VERIFY_LITTLE_REPRESENTATION( little_int40_ut );
-    VERIFY_VALUE_AND_OPS( little_int40_ut, int_least64_t,  0x7fffffffffLL );
-    VERIFY_VALUE_AND_OPS( little_int40_ut, int_least64_t, -0x8000000000LL );
-
-    VERIFY_LITTLE_REPRESENTATION( little_int48_ut );
-    VERIFY_VALUE_AND_OPS( little_int48_ut, int_least64_t,  0x7fffffffffffLL );
-    VERIFY_VALUE_AND_OPS( little_int48_ut, int_least64_t, -0x800000000000LL );
-
-    VERIFY_LITTLE_REPRESENTATION( little_int56_ut );
-    VERIFY_VALUE_AND_OPS( little_int56_ut, int_least64_t,  0x7fffffffffffffLL );
-    VERIFY_VALUE_AND_OPS( little_int56_ut, int_least64_t, -0x80000000000000LL );
-
-    VERIFY_LITTLE_REPRESENTATION( little_int64_ut );
-    VERIFY_VALUE_AND_OPS( little_int64_ut, int_least64_t,  0x7fffffffffffffffLL );
-    VERIFY_VALUE_AND_OPS( little_int64_ut, int_least64_t, -0x7fffffffffffffffLL-1 );
-
-    VERIFY_LITTLE_REPRESENTATION( little_uint8_ut );
-    VERIFY_VALUE_AND_OPS( little_uint8_ut, uint_least8_t, 0xff );
-
-    VERIFY_LITTLE_REPRESENTATION( little_uint16_ut );
-    VERIFY_VALUE_AND_OPS( little_uint16_ut, uint_least16_t, 0xffff );
-
-    VERIFY_LITTLE_REPRESENTATION( little_uint24_ut );
-    VERIFY_VALUE_AND_OPS( little_uint24_ut, uint_least32_t, 0xffffff );
-
-    VERIFY_LITTLE_REPRESENTATION( little_uint32_ut );
-    VERIFY_VALUE_AND_OPS( little_uint32_ut, uint_least32_t, 0xffffffff );
-
-    VERIFY_LITTLE_REPRESENTATION( little_uint40_ut );
-    VERIFY_VALUE_AND_OPS( little_uint40_ut, uint_least64_t, 0xffffffffffLL );
-
-    VERIFY_LITTLE_REPRESENTATION( little_uint48_ut );
-    VERIFY_VALUE_AND_OPS( little_uint48_ut, uint_least64_t, 0xffffffffffffLL );
-
-    VERIFY_LITTLE_REPRESENTATION( little_uint56_ut );
-    VERIFY_VALUE_AND_OPS( little_uint56_ut, uint_least64_t, 0xffffffffffffffLL );
-
-    VERIFY_LITTLE_REPRESENTATION( little_uint64_ut );
-    VERIFY_VALUE_AND_OPS( little_uint64_ut, uint_least64_t, 0xffffffffffffffffULL );
-
-    VERIFY_NATIVE_REPRESENTATION( native_int8_ut );
-    VERIFY_VALUE_AND_OPS( native_int8_ut, int_least8_t,   0x7f );
-    VERIFY_VALUE_AND_OPS( native_int8_ut, int_least8_t,  -0x80 );
-
-    VERIFY_NATIVE_REPRESENTATION( native_int16_ut );
-    VERIFY_VALUE_AND_OPS( native_int16_ut, int_least16_t,  0x7fff );
-    VERIFY_VALUE_AND_OPS( native_int16_ut, int_least16_t, -0x8000 );
-
-    VERIFY_NATIVE_REPRESENTATION( native_int24_ut );
-    VERIFY_VALUE_AND_OPS( native_int24_ut, int_least32_t,  0x7fffff );
-    VERIFY_VALUE_AND_OPS( native_int24_ut, int_least32_t, -0x800000 );
-
-    VERIFY_NATIVE_REPRESENTATION( native_int32_ut );
-    VERIFY_VALUE_AND_OPS( native_int32_ut, int_least32_t,  0x7fffffff );
-    VERIFY_VALUE_AND_OPS( native_int32_ut, int_least32_t, -0x7fffffff-1 );
-
-    VERIFY_NATIVE_REPRESENTATION( native_int40_ut );
-    VERIFY_VALUE_AND_OPS( native_int40_ut, int_least64_t,  0x7fffffffffLL );
-    VERIFY_VALUE_AND_OPS( native_int40_ut, int_least64_t, -0x8000000000LL );
-
-    VERIFY_NATIVE_REPRESENTATION( native_int48_ut );
-    VERIFY_VALUE_AND_OPS( native_int48_ut, int_least64_t,  0x7fffffffffffLL );
-    VERIFY_VALUE_AND_OPS( native_int48_ut, int_least64_t, -0x800000000000LL );
-
-    VERIFY_NATIVE_REPRESENTATION( native_int56_ut );
-    VERIFY_VALUE_AND_OPS( native_int56_ut, int_least64_t,  0x7fffffffffffffLL );
-    VERIFY_VALUE_AND_OPS( native_int56_ut, int_least64_t, -0x80000000000000LL );
-
-    VERIFY_NATIVE_REPRESENTATION( native_int64_ut );
-    VERIFY_VALUE_AND_OPS( native_int64_ut, int_least64_t,  0x7fffffffffffffffLL );
-    VERIFY_VALUE_AND_OPS( native_int64_ut, int_least64_t, -0x7fffffffffffffffLL-1 );
-
-    VERIFY_NATIVE_REPRESENTATION( native_uint8_ut );
-    VERIFY_VALUE_AND_OPS( native_uint8_ut, uint_least8_t, 0xff );
-
-    VERIFY_NATIVE_REPRESENTATION( native_uint16_ut );
-    VERIFY_VALUE_AND_OPS( native_uint16_ut, uint_least16_t, 0xffff );
-
-    VERIFY_NATIVE_REPRESENTATION( native_uint24_ut );
-    VERIFY_VALUE_AND_OPS( native_uint24_ut, uint_least32_t, 0xffffff );
-
-    VERIFY_NATIVE_REPRESENTATION( native_uint32_ut );
-    VERIFY_VALUE_AND_OPS( native_uint32_ut, uint_least32_t, 0xffffffff );
-
-    VERIFY_NATIVE_REPRESENTATION( native_uint40_ut );
-    VERIFY_VALUE_AND_OPS( native_uint40_ut, uint_least64_t, 0xffffffffffLL );
-
-    VERIFY_NATIVE_REPRESENTATION( native_uint48_ut );
-    VERIFY_VALUE_AND_OPS( native_uint48_ut, uint_least64_t, 0xffffffffffffLL );
-
-    VERIFY_NATIVE_REPRESENTATION( native_uint56_ut );
-    VERIFY_VALUE_AND_OPS( native_uint56_ut, uint_least64_t, 0xffffffffffffffLL );
-
-    VERIFY_NATIVE_REPRESENTATION( native_uint64_ut );
-    VERIFY_VALUE_AND_OPS( native_uint64_ut, uint_least64_t, 0xffffffffffffffffULL );
-
-    // aligned integer types
     VERIFY_BIG_REPRESENTATION( big_int16_t );
     VERIFY_VALUE_AND_OPS( big_int16_t, int_least16_t,  0x7fff );
     VERIFY_VALUE_AND_OPS( big_int16_t, int_least16_t, -0x8000 );
 
+    VERIFY_BIG_REPRESENTATION( big_int24_t );
+    VERIFY_VALUE_AND_OPS( big_int24_t, int_least32_t,  0x7fffff );
+    VERIFY_VALUE_AND_OPS( big_int24_t, int_least32_t, -0x800000 );
+
     VERIFY_BIG_REPRESENTATION( big_int32_t );
     VERIFY_VALUE_AND_OPS( big_int32_t, int_least32_t,  0x7fffffff );
     VERIFY_VALUE_AND_OPS( big_int32_t, int_least32_t, -0x7fffffff-1 );
 
+    VERIFY_BIG_REPRESENTATION( big_int40_t );
+    VERIFY_VALUE_AND_OPS( big_int40_t, int_least64_t,  0x7fffffffffLL );
+    VERIFY_VALUE_AND_OPS( big_int40_t, int_least64_t, -0x8000000000LL );
+
+    VERIFY_BIG_REPRESENTATION( big_int48_t );
+    VERIFY_VALUE_AND_OPS( big_int48_t, int_least64_t,  0x7fffffffffffLL );
+    VERIFY_VALUE_AND_OPS( big_int48_t, int_least64_t, -0x800000000000LL );
+
+    VERIFY_BIG_REPRESENTATION( big_int56_t );
+    VERIFY_VALUE_AND_OPS( big_int56_t, int_least64_t,  0x7fffffffffffffLL );
+    VERIFY_VALUE_AND_OPS( big_int56_t, int_least64_t, -0x80000000000000LL );
+
     VERIFY_BIG_REPRESENTATION( big_int64_t );
     VERIFY_VALUE_AND_OPS( big_int64_t, int_least64_t,  0x7fffffffffffffffLL );
     VERIFY_VALUE_AND_OPS( big_int64_t, int_least64_t, -0x7fffffffffffffffLL-1 );
 
+    VERIFY_BIG_REPRESENTATION( big_uint8_t );
+    VERIFY_VALUE_AND_OPS( big_uint8_t, uint_least8_t,  0xff );
+
     VERIFY_BIG_REPRESENTATION( big_uint16_t );
     VERIFY_VALUE_AND_OPS( big_uint16_t, uint_least16_t, 0xffff );
 
+    VERIFY_BIG_REPRESENTATION( big_uint24_t );
+    VERIFY_VALUE_AND_OPS( big_uint24_t, uint_least32_t, 0xffffff );
+
     VERIFY_BIG_REPRESENTATION( big_uint32_t );
     VERIFY_VALUE_AND_OPS( big_uint32_t, uint_least32_t, 0xffffffff );
 
+    VERIFY_BIG_REPRESENTATION( big_uint40_t );
+    VERIFY_VALUE_AND_OPS( big_uint40_t, uint_least64_t, 0xffffffffffLL );
+
+    VERIFY_BIG_REPRESENTATION( big_uint48_t );
+    VERIFY_VALUE_AND_OPS( big_uint48_t, uint_least64_t, 0xffffffffffffLL );
+
+    VERIFY_BIG_REPRESENTATION( big_uint56_t );
+    VERIFY_VALUE_AND_OPS( big_uint56_t, uint_least64_t, 0xffffffffffffffLL );
+
     VERIFY_BIG_REPRESENTATION( big_uint64_t );
     VERIFY_VALUE_AND_OPS( big_uint64_t, uint_least64_t, 0xffffffffffffffffULL );
 
+    VERIFY_LITTLE_REPRESENTATION( little_int8_t );
+    VERIFY_VALUE_AND_OPS( little_int8_t, int_least8_t,   0x7f );
+    VERIFY_VALUE_AND_OPS( little_int8_t, int_least8_t,  -0x80 );
+
     VERIFY_LITTLE_REPRESENTATION( little_int16_t );
     VERIFY_VALUE_AND_OPS( little_int16_t, int_least16_t,  0x7fff );
     VERIFY_VALUE_AND_OPS( little_int16_t, int_least16_t, -0x8000 );
 
+    VERIFY_LITTLE_REPRESENTATION( little_int24_t );
+    VERIFY_VALUE_AND_OPS( little_int24_t, int_least32_t,  0x7fffff );
+    VERIFY_VALUE_AND_OPS( little_int24_t, int_least32_t, -0x800000 );
+
     VERIFY_LITTLE_REPRESENTATION( little_int32_t );
     VERIFY_VALUE_AND_OPS( little_int32_t, int_least32_t,  0x7fffffff );
     VERIFY_VALUE_AND_OPS( little_int32_t, int_least32_t, -0x7fffffff-1 );
 
+    VERIFY_LITTLE_REPRESENTATION( little_int40_t );
+    VERIFY_VALUE_AND_OPS( little_int40_t, int_least64_t,  0x7fffffffffLL );
+    VERIFY_VALUE_AND_OPS( little_int40_t, int_least64_t, -0x8000000000LL );
+
+    VERIFY_LITTLE_REPRESENTATION( little_int48_t );
+    VERIFY_VALUE_AND_OPS( little_int48_t, int_least64_t,  0x7fffffffffffLL );
+    VERIFY_VALUE_AND_OPS( little_int48_t, int_least64_t, -0x800000000000LL );
+
+    VERIFY_LITTLE_REPRESENTATION( little_int56_t );
+    VERIFY_VALUE_AND_OPS( little_int56_t, int_least64_t,  0x7fffffffffffffLL );
+    VERIFY_VALUE_AND_OPS( little_int56_t, int_least64_t, -0x80000000000000LL );
+
     VERIFY_LITTLE_REPRESENTATION( little_int64_t );
     VERIFY_VALUE_AND_OPS( little_int64_t, int_least64_t,  0x7fffffffffffffffLL );
     VERIFY_VALUE_AND_OPS( little_int64_t, int_least64_t, -0x7fffffffffffffffLL-1 );
 
+    VERIFY_LITTLE_REPRESENTATION( little_uint8_t );
+    VERIFY_VALUE_AND_OPS( little_uint8_t, uint_least8_t, 0xff );
+
     VERIFY_LITTLE_REPRESENTATION( little_uint16_t );
     VERIFY_VALUE_AND_OPS( little_uint16_t, uint_least16_t, 0xffff );
 
+    VERIFY_LITTLE_REPRESENTATION( little_uint24_t );
+    VERIFY_VALUE_AND_OPS( little_uint24_t, uint_least32_t, 0xffffff );
+
     VERIFY_LITTLE_REPRESENTATION( little_uint32_t );
     VERIFY_VALUE_AND_OPS( little_uint32_t, uint_least32_t, 0xffffffff );
 
+    VERIFY_LITTLE_REPRESENTATION( little_uint40_t );
+    VERIFY_VALUE_AND_OPS( little_uint40_t, uint_least64_t, 0xffffffffffLL );
+
+    VERIFY_LITTLE_REPRESENTATION( little_uint48_t );
+    VERIFY_VALUE_AND_OPS( little_uint48_t, uint_least64_t, 0xffffffffffffLL );
+
+    VERIFY_LITTLE_REPRESENTATION( little_uint56_t );
+    VERIFY_VALUE_AND_OPS( little_uint56_t, uint_least64_t, 0xffffffffffffffLL );
+
     VERIFY_LITTLE_REPRESENTATION( little_uint64_t );
     VERIFY_VALUE_AND_OPS( little_uint64_t, uint_least64_t, 0xffffffffffffffffULL );
 
+    VERIFY_NATIVE_REPRESENTATION( native_int8_t );
+    VERIFY_VALUE_AND_OPS( native_int8_t, int_least8_t,   0x7f );
+    VERIFY_VALUE_AND_OPS( native_int8_t, int_least8_t,  -0x80 );
+
+    VERIFY_NATIVE_REPRESENTATION( native_int16_t );
+    VERIFY_VALUE_AND_OPS( native_int16_t, int_least16_t,  0x7fff );
+    VERIFY_VALUE_AND_OPS( native_int16_t, int_least16_t, -0x8000 );
+
+    VERIFY_NATIVE_REPRESENTATION( native_int24_t );
+    VERIFY_VALUE_AND_OPS( native_int24_t, int_least32_t,  0x7fffff );
+    VERIFY_VALUE_AND_OPS( native_int24_t, int_least32_t, -0x800000 );
+
+    VERIFY_NATIVE_REPRESENTATION( native_int32_t );
+    VERIFY_VALUE_AND_OPS( native_int32_t, int_least32_t,  0x7fffffff );
+    VERIFY_VALUE_AND_OPS( native_int32_t, int_least32_t, -0x7fffffff-1 );
+
+    VERIFY_NATIVE_REPRESENTATION( native_int40_t );
+    VERIFY_VALUE_AND_OPS( native_int40_t, int_least64_t,  0x7fffffffffLL );
+    VERIFY_VALUE_AND_OPS( native_int40_t, int_least64_t, -0x8000000000LL );
+
+    VERIFY_NATIVE_REPRESENTATION( native_int48_t );
+    VERIFY_VALUE_AND_OPS( native_int48_t, int_least64_t,  0x7fffffffffffLL );
+    VERIFY_VALUE_AND_OPS( native_int48_t, int_least64_t, -0x800000000000LL );
+
+    VERIFY_NATIVE_REPRESENTATION( native_int56_t );
+    VERIFY_VALUE_AND_OPS( native_int56_t, int_least64_t,  0x7fffffffffffffLL );
+    VERIFY_VALUE_AND_OPS( native_int56_t, int_least64_t, -0x80000000000000LL );
+
+    VERIFY_NATIVE_REPRESENTATION( native_int64_t );
+    VERIFY_VALUE_AND_OPS( native_int64_t, int_least64_t,  0x7fffffffffffffffLL );
+    VERIFY_VALUE_AND_OPS( native_int64_t, int_least64_t, -0x7fffffffffffffffLL-1 );
+
+    VERIFY_NATIVE_REPRESENTATION( native_uint8_t );
+    VERIFY_VALUE_AND_OPS( native_uint8_t, uint_least8_t, 0xff );
+
+    VERIFY_NATIVE_REPRESENTATION( native_uint16_t );
+    VERIFY_VALUE_AND_OPS( native_uint16_t, uint_least16_t, 0xffff );
+
+    VERIFY_NATIVE_REPRESENTATION( native_uint24_t );
+    VERIFY_VALUE_AND_OPS( native_uint24_t, uint_least32_t, 0xffffff );
+
+    VERIFY_NATIVE_REPRESENTATION( native_uint32_t );
+    VERIFY_VALUE_AND_OPS( native_uint32_t, uint_least32_t, 0xffffffff );
+
+    VERIFY_NATIVE_REPRESENTATION( native_uint40_t );
+    VERIFY_VALUE_AND_OPS( native_uint40_t, uint_least64_t, 0xffffffffffLL );
+
+    VERIFY_NATIVE_REPRESENTATION( native_uint48_t );
+    VERIFY_VALUE_AND_OPS( native_uint48_t, uint_least64_t, 0xffffffffffffLL );
+
+    VERIFY_NATIVE_REPRESENTATION( native_uint56_t );
+    VERIFY_VALUE_AND_OPS( native_uint56_t, uint_least64_t, 0xffffffffffffffLL );
+
+    VERIFY_NATIVE_REPRESENTATION( native_uint64_t );
+    VERIFY_VALUE_AND_OPS( native_uint64_t, uint_least64_t, 0xffffffffffffffffULL );
+
+    // aligned integer types
+    VERIFY_BIG_REPRESENTATION( big_int16_at );
+    VERIFY_VALUE_AND_OPS( big_int16_at, int_least16_t,  0x7fff );
+    VERIFY_VALUE_AND_OPS( big_int16_at, int_least16_t, -0x8000 );
+
+    VERIFY_BIG_REPRESENTATION( big_int32_at );
+    VERIFY_VALUE_AND_OPS( big_int32_at, int_least32_t,  0x7fffffff );
+    VERIFY_VALUE_AND_OPS( big_int32_at, int_least32_t, -0x7fffffff-1 );
+
+    VERIFY_BIG_REPRESENTATION( big_int64_at );
+    VERIFY_VALUE_AND_OPS( big_int64_at, int_least64_t,  0x7fffffffffffffffLL );
+    VERIFY_VALUE_AND_OPS( big_int64_at, int_least64_t, -0x7fffffffffffffffLL-1 );
+
+    VERIFY_BIG_REPRESENTATION( big_uint16_at );
+    VERIFY_VALUE_AND_OPS( big_uint16_at, uint_least16_t, 0xffff );
+
+    VERIFY_BIG_REPRESENTATION( big_uint32_at );
+    VERIFY_VALUE_AND_OPS( big_uint32_at, uint_least32_t, 0xffffffff );
+
+    VERIFY_BIG_REPRESENTATION( big_uint64_at );
+    VERIFY_VALUE_AND_OPS( big_uint64_at, uint_least64_t, 0xffffffffffffffffULL );
+
+    VERIFY_LITTLE_REPRESENTATION( little_int16_at );
+    VERIFY_VALUE_AND_OPS( little_int16_at, int_least16_t,  0x7fff );
+    VERIFY_VALUE_AND_OPS( little_int16_at, int_least16_t, -0x8000 );
+
+    VERIFY_LITTLE_REPRESENTATION( little_int32_at );
+    VERIFY_VALUE_AND_OPS( little_int32_at, int_least32_t,  0x7fffffff );
+    VERIFY_VALUE_AND_OPS( little_int32_at, int_least32_t, -0x7fffffff-1 );
+
+    VERIFY_LITTLE_REPRESENTATION( little_int64_at );
+    VERIFY_VALUE_AND_OPS( little_int64_at, int_least64_t,  0x7fffffffffffffffLL );
+    VERIFY_VALUE_AND_OPS( little_int64_at, int_least64_t, -0x7fffffffffffffffLL-1 );
+
+    VERIFY_LITTLE_REPRESENTATION( little_uint16_at );
+    VERIFY_VALUE_AND_OPS( little_uint16_at, uint_least16_t, 0xffff );
+
+    VERIFY_LITTLE_REPRESENTATION( little_uint32_at );
+    VERIFY_VALUE_AND_OPS( little_uint32_at, uint_least32_t, 0xffffffff );
+
+    VERIFY_LITTLE_REPRESENTATION( little_uint64_at );
+    VERIFY_VALUE_AND_OPS( little_uint64_at, uint_least64_t, 0xffffffffffffffffULL );
+
   } // check_representation_and_range
 
   class MyInt
@@ -968,10 +968,10 @@ int cpp_main( int argc, char * argv[] )
   check_data();
   check_udt();
 
-  //timing_test ( "big_int32_ut" );
-  //timing_test( "big_int32_t" );
-  //timing_test ( "little_int32_ut" );
-  //timing_test( "little_int32_t" );
+  //timing_test ( "big_int32_t" );
+  //timing_test( "big_int32_at" );
+  //timing_test ( "little_int32_t" );
+  //timing_test( "little_int32_at" );
 
   cout << "\n" << err_count << " errors detected\nTest "
        << (err_count==0 ? "passed\n\n" : "failed\n\n");
diff --git a/test/loop_time_test.cpp b/test/loop_time_test.cpp
index e36ffbd..f9c3ddf 100644
--- a/test/loop_time_test.cpp
+++ b/test/loop_time_test.cpp
@@ -162,84 +162,84 @@ namespace
   void test_big_align_int16()
   {
     cout << "
16-bit aligned big endian
16-bit aligned little endian
16-bit unaligned big endian
16-bit unaligned little endian
32-bit aligned big endian
32-bit aligned little endian
32-bit unaligned big endian
32-bit unaligned little endian
64-bit aligned big endian
64-bit aligned little endian
64-bit unaligned big endian
64-bit unaligned little endian