From 1573a2c4739f04d88a3f5f39e9fbcb8d5eebfd3b Mon Sep 17 00:00:00 2001
From: jzmaddock <john@johnmaddock.co.uk>
Date: Fri, 13 Oct 2023 19:45:24 +0100
Subject: [PATCH] Add support for C++23 <stdfloat> types.

---
 .drone.star                                   |  1 +
 .../boost/type_traits/is_floating_point.hpp   | 22 ++++++++++
 test/is_arithmetic_test.cpp                   | 36 +++++++++++++++
 test/is_floating_point_test.cpp               | 36 +++++++++++++++
 test/is_fundamental_test.cpp                  | 36 +++++++++++++++
 test/is_pod_test.cpp                          | 44 ++++++++++++++++---
 test/is_scalar_test.cpp                       | 42 +++++++++++++++---
 7 files changed, 204 insertions(+), 13 deletions(-)

diff --git a/.drone.star b/.drone.star
index bdb1d43d21..6a650532d4 100644
--- a/.drone.star
+++ b/.drone.star
@@ -41,6 +41,7 @@ def main(ctx):
   linux_cxx("TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17 2a Job 26", "clang++-8", packages="clang-8", llvm_os="xenial", llvm_ver="8", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '03,11,14,17,2a'}, globalenv=globalenv),
   linux_cxx("TOOLSET=clang COMPILER=clang++-9 CXXSTD=03,11,14,17,2a Job 27", "clang++-9", packages="clang-9", llvm_os="xenial", llvm_ver="9", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '03,11,14,17,2a'}, globalenv=globalenv),
   linux_cxx("TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,20 Job 28", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '03,11,14,17,20'}, globalenv=globalenv),
+  linux_cxx("Ubuntu g++-13", packages="g++-13", buildtype="boost", image="cppalliance/droneubuntu2304:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-13', 'CXXSTD': '14,17,20,23', }, globalenv=globalenv),
   osx_cxx("XCode-11.7 CXXSTD=03,11,14,17,2a Job 29", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11,14,17,2a', 'DRONE_JOB_OS_NAME': 'osx'}, globalenv=globalenv),
   osx_cxx("XCode-10.2 CXXSTD=03,11,14,17,2a Job 30", "clang++", packages="", buildtype="boost", xcode_version="10.2", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11,14,17,2a', 'DRONE_JOB_OS_NAME': 'osx'}, globalenv=globalenv),
   osx_cxx("XCode-9.4 CXXSTD=03,11,14,1z Job 31", "clang++", packages="", buildtype="boost", xcode_version="9.4", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_OS_NAME': 'osx'}, globalenv=globalenv),
diff --git a/include/boost/type_traits/is_floating_point.hpp b/include/boost/type_traits/is_floating_point.hpp
index 196c900cf9..f9f3d39567 100644
--- a/include/boost/type_traits/is_floating_point.hpp
+++ b/include/boost/type_traits/is_floating_point.hpp
@@ -10,6 +10,10 @@
 
 #include <boost/type_traits/integral_constant.hpp>
 
+#ifndef BOOST_NO_CXX23_HDR_STDFLOAT
+#include <stdfloat>
+#endif
+
 namespace boost {
 
 //* is a type T a floating-point type described in the standard (3.9.1p8)
@@ -25,6 +29,24 @@ namespace boost {
    template<> struct is_floating_point<__float128> : public true_type{};
 #endif
 
+#ifndef BOOST_NO_CXX23_HDR_STDFLOAT
+#if defined(__STDCPP_FLOAT16_T__)
+   template<> struct is_floating_point<std::float16_t> : public true_type {};
+#endif
+#if defined(__STDCPP_FLOAT32_T__)
+   template<> struct is_floating_point<std::float32_t> : public true_type {};
+#endif
+#if defined(__STDCPP_FLOAT64_T__)
+   template<> struct is_floating_point<std::float64_t> : public true_type {};
+#endif
+#if defined(__STDCPP_FLOAT128_T__)
+   template<> struct is_floating_point<std::float128_t> : public true_type {};
+#endif
+#if defined(__STDCPP_BFLOAT16_T__)
+   template<> struct is_floating_point<std::bfloat16_t> : public true_type {};
+#endif
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED
diff --git a/test/is_arithmetic_test.cpp b/test/is_arithmetic_test.cpp
index 13007cbfeb..e911d381b3 100644
--- a/test/is_arithmetic_test.cpp
+++ b/test/is_arithmetic_test.cpp
@@ -12,6 +12,10 @@
 #include "test.hpp"
 #include "check_integral_constant.hpp"
 
+#ifndef BOOST_NO_CXX23_HDR_STDFLOAT
+#include <stdfloat>
+#endif
+
 TT_TEST_BEGIN(is_arithmetic)
 
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<bool>::value, true);
@@ -159,6 +163,38 @@ BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<boost::uint128_type>::value, t
 #ifdef BOOST_HAS_FLOAT128
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<boost::float128_type>::value, true);
 #endif
+#ifndef BOOST_NO_CXX23_HDR_STDFLOAT
+#if defined(__STDCPP_FLOAT16_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<std::float16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<const std::float16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<volatile std::float16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<const volatile std::float16_t>::value, true);
+#endif
+#if defined(__STDCPP_FLOAT32_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<const std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<volatile std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<const volatile std::float32_t>::value, true);
+#endif
+#if defined(__STDCPP_FLOAT64_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<const std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<volatile std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<const volatile std::float32_t>::value, true);
+#endif
+#if defined(__STDCPP_FLOAT128_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<std::float128_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<const std::float128_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<volatile std::float128_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<const volatile std::float128_t>::value, true);
+#endif
+#if defined(__STDCPP_BFLOAT16_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<std::bfloat16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<const std::bfloat16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<volatile std::bfloat16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_arithmetic<const volatile std::bfloat16_t>::value, true);
+#endif
+#endif
 
 TT_TEST_END
 
diff --git a/test/is_floating_point_test.cpp b/test/is_floating_point_test.cpp
index c9b15b03e3..fca569fad1 100644
--- a/test/is_floating_point_test.cpp
+++ b/test/is_floating_point_test.cpp
@@ -12,6 +12,10 @@
 #include "test.hpp"
 #include "check_integral_constant.hpp"
 
+#ifndef BOOST_NO_CXX23_HDR_STDFLOAT
+#include <stdfloat>
+#endif
+
 TT_TEST_BEGIN(is_floating_point)
 
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<float>::value, true);
@@ -35,6 +39,38 @@ BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<const __float128>::value,
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<volatile __float128>::value, true);
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<const volatile __float128>::value, true);
 #endif
+#ifndef BOOST_NO_CXX23_HDR_STDFLOAT
+#if defined(__STDCPP_FLOAT16_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<std::float16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<const std::float16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<volatile std::float16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<const volatile std::float16_t>::value, true);
+#endif
+#if defined(__STDCPP_FLOAT32_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<const std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<volatile std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<const volatile std::float32_t>::value, true);
+#endif
+#if defined(__STDCPP_FLOAT64_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<const std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<volatile std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<const volatile std::float32_t>::value, true);
+#endif
+#if defined(__STDCPP_FLOAT128_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<std::float128_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<const std::float128_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<volatile std::float128_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<const volatile std::float128_t>::value, true);
+#endif
+#if defined(__STDCPP_BFLOAT16_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<std::bfloat16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<const std::bfloat16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<volatile std::bfloat16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_floating_point<const volatile std::bfloat16_t>::value, true);
+#endif
+#endif
 
 //
 // cases that should not be true:
diff --git a/test/is_fundamental_test.cpp b/test/is_fundamental_test.cpp
index ab97f9893f..6d2cd39c3b 100644
--- a/test/is_fundamental_test.cpp
+++ b/test/is_fundamental_test.cpp
@@ -12,6 +12,10 @@
 #include "test.hpp"
 #include "check_integral_constant.hpp"
 
+#ifndef BOOST_NO_CXX23_HDR_STDFLOAT
+#include <stdfloat>
+#endif
+
 TT_TEST_BEGIN(is_fundamental)
 
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<void>::value, true);
@@ -164,6 +168,38 @@ BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<boost::uint128_type>::value,
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<boost::float128_type>::value, true);
 #endif
 
+#ifndef BOOST_NO_CXX23_HDR_STDFLOAT
+#if defined(__STDCPP_FLOAT16_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<std::float16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<const std::float16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<volatile std::float16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<const volatile std::float16_t>::value, true);
+#endif
+#if defined(__STDCPP_FLOAT32_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<const std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<volatile std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<const volatile std::float32_t>::value, true);
+#endif
+#if defined(__STDCPP_FLOAT64_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<const std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<volatile std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<const volatile std::float32_t>::value, true);
+#endif
+#if defined(__STDCPP_FLOAT128_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<std::float128_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<const std::float128_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<volatile std::float128_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<const volatile std::float128_t>::value, true);
+#endif
+#if defined(__STDCPP_BFLOAT16_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<std::bfloat16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<const std::bfloat16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<volatile std::bfloat16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_fundamental<const volatile std::bfloat16_t>::value, true);
+#endif
+#endif
 TT_TEST_END
 
 
diff --git a/test/is_pod_test.cpp b/test/is_pod_test.cpp
index 861037c317..eab158da28 100644
--- a/test/is_pod_test.cpp
+++ b/test/is_pod_test.cpp
@@ -12,6 +12,10 @@
 #include "test.hpp"
 #include "check_integral_constant.hpp"
 
+#ifndef BOOST_NO_CXX23_HDR_STDFLOAT
+#include <stdfloat>
+#endif
+
 TT_TEST_BEGIN(is_pod)
 
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<bool>::value, true);
@@ -186,12 +190,38 @@ BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<boost::uint128_type>::value, true);
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<boost::float128_type>::value, true);
 #endif
 
-TT_TEST_END
-
-
-
-
-
-
+#ifndef BOOST_NO_CXX23_HDR_STDFLOAT
+#if defined(__STDCPP_FLOAT16_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<std::float16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<const std::float16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<volatile std::float16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<const volatile std::float16_t>::value, true);
+#endif
+#if defined(__STDCPP_FLOAT32_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<const std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<volatile std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<const volatile std::float32_t>::value, true);
+#endif
+#if defined(__STDCPP_FLOAT64_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<const std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<volatile std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<const volatile std::float32_t>::value, true);
+#endif
+#if defined(__STDCPP_FLOAT128_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<std::float128_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<const std::float128_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<volatile std::float128_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<const volatile std::float128_t>::value, true);
+#endif
+#if defined(__STDCPP_BFLOAT16_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<std::bfloat16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<const std::bfloat16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<volatile std::bfloat16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_pod<const volatile std::bfloat16_t>::value, true);
+#endif
+#endif
 
+TT_TEST_END
 
diff --git a/test/is_scalar_test.cpp b/test/is_scalar_test.cpp
index 2017d0f00b..77b29afeef 100644
--- a/test/is_scalar_test.cpp
+++ b/test/is_scalar_test.cpp
@@ -12,6 +12,10 @@
 #include "test.hpp"
 #include "check_integral_constant.hpp"
 
+#ifndef BOOST_NO_CXX23_HDR_STDFLOAT
+#include <stdfloat>
+#endif
+
 TT_TEST_BEGIN(is_scalar)
 
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<bool>::value, true);
@@ -165,13 +169,39 @@ BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<boost::uint128_type>::value, true)
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<boost::float128_type>::value, true);
 #endif
 
+#ifndef BOOST_NO_CXX23_HDR_STDFLOAT
+#if defined(__STDCPP_FLOAT16_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<std::float16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<const std::float16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<volatile std::float16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<const volatile std::float16_t>::value, true);
+#endif
+#if defined(__STDCPP_FLOAT32_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<const std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<volatile std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<const volatile std::float32_t>::value, true);
+#endif
+#if defined(__STDCPP_FLOAT64_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<const std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<volatile std::float32_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<const volatile std::float32_t>::value, true);
+#endif
+#if defined(__STDCPP_FLOAT128_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<std::float128_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<const std::float128_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<volatile std::float128_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<const volatile std::float128_t>::value, true);
+#endif
+#if defined(__STDCPP_BFLOAT16_T__)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<std::bfloat16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<const std::bfloat16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<volatile std::bfloat16_t>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scalar<const volatile std::bfloat16_t>::value, true);
+#endif
+#endif
 
 TT_TEST_END
 
 
-
-
-
-
-
-