VS2022 (Version 17.8.1) can build

Question

VS2022 (Version 17.8.1) can build

Closed this issue 10 months ago · 6 comments

after 'Cmake .' and open and compile from solution get:

Severity Code Description Project File Line Suppression State Details
Error C2039 '_Countl_zero_fallback': is not a member of 'std' fixed_math D:\UE5\fixed_math-master\fixed_lib\include\fixedmath\detail\utility_cxx20.h 113
Error C3861 '_Countl_zero_fallback': identifier not found fixed_math D:\UE5\fixed_math-master\fixed_lib\include\fixedmath\detail\utility_cxx20.h 113
Error C3615 constexpr function 'cxx20::countl_zero' cannot result in a constant expression fixed_math D:\UE5\fixed_math-master\fixed_lib\include\fixedmath\detail\utility_cxx20.h 139
Error C3615 constexpr function 'cxx20::countl_zero' cannot result in a constant expression fixed_math D:\UE5\fixed_math-master\fixed_lib\include\fixedmath\detail\utility_cxx20.h 140
Error C3615 constexpr function 'cxx20::countl_zero' cannot result in a constant expression fixed_math D:\UE5\fixed_math-master\fixed_lib\include\fixedmath\detail\utility_cxx20.h 141
Error C3615 constexpr function 'cxx20::countl_zero' cannot result in a constant expression fixed_math D:\UE5\fixed_math-master\fixed_lib\include\fixedmath\detail\utility_cxx20.h 142
Error C3615 constexpr function 'cxx20::countl_zero' cannot result in a constant expression fixed_math D:\UE5\fixed_math-master\fixed_lib\include\fixedmath\detail\utility_cxx20.h 143
Error C3615 constexpr function 'cxx20::countl_zero' cannot result in a constant expression fixed_math D:\UE5\fixed_math-master\fixed_lib\include\fixedmath\detail\utility_cxx20.h 144
Warning C4067 unexpected tokens following preprocessor directive - expected a newline fixed_math D:\UE5\fixed_math-master\fixed_lib\include\fixedmath\detail\utility_cxx20.h 185
Error C1189 #error: "Not bit_cast support at all implement using std::memcpy" fixed_math D:\UE5\fixed_math-master\fixed_lib\include\fixedmath\detail\utility_cxx20.h 186

Answer 1 · 2023-11-24T07:15:42.000Z

What c++ standard are You using in Your project ?

Answer 2 · 2023-11-24T13:58:55.000Z

C++17 Get Outlook for Android<https://aka.ms/AAb9ysg>

…

________________________________ From: Artur Bać ***@***.***> Sent: Friday, November 24, 2023 2:15:53 AM To: arturbac/fixed_math ***@***.***> Cc: RobertMassart ***@***.***>; Author ***@***.***> Subject: Re: [arturbac/fixed_math] VS2022 (Version 17.8.1) can build (Issue #1) What c++ standard are You using in Your project ? — Reply to this email directly, view it on GitHub<#1 (comment)>, or unsubscribe<https://github.com/notifications/unsubscribe-auth/AFITVWPAGACVWPKUL2X3FPTYGBCSTAVCNFSM6AAAAAA7X7V7ESVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMYTQMRVGIZTQNRTGQ>. You are receiving this because you authored the thread.Message ID: ***@***.***>

Answer 3 · 2023-11-24T14:14:54.000Z

I went back to fixed_math-0.9.11 and update the utility_cxx20.h to detect vs2022 C++20 correctly and C++17. But for latest branch if c++17 you get: Build started at 9:12 AM... 1>------ Build started: Project: fixed_math, Configuration: Debug x64 ------ 1>fixed_math.cc 1>D:\UE5\fixed_math-master\fixed_lib\include\fixedmath\detail\utility_cxx20.h(221,23): warning C4067: unexpected tokens following preprocessor directive - expected a newline 1>(compiling source file 'src/fixed_math.cc') 1>D:\UE5\fixed_math-master\fixed_lib\include\fixedmath\detail\utility_cxx20.h(222,1): error C1189: #error: "Not bit_cast support at all implement using std::memcpy" 1>(compiling source file 'src/fixed_math.cc') 1>Done building project "fixed_math.vcxproj" -- FAILED. For latest branch and c++20 I can get it to compile with changes attached (I append _master) so you will know which header applied to master. From: Robert Massart ***@***.***> Sent: Friday, November 24, 2023 8:59 AM To: arturbac/fixed_math ***@***.***>; arturbac/fixed_math ***@***.***> Cc: Author ***@***.***> Subject: Re: [arturbac/fixed_math] VS2022 (Version 17.8.1) can build (Issue #1) C++17 Get Outlook for Android<https://aka.ms/AAb9ysg>

…

________________________________ From: Artur Bać ***@***.******@***.***>> Sent: Friday, November 24, 2023 2:15:53 AM To: arturbac/fixed_math ***@***.******@***.***>> Cc: RobertMassart ***@***.******@***.***>>; Author ***@***.******@***.***>> Subject: Re: [arturbac/fixed_math] VS2022 (Version 17.8.1) can build (Issue #1) What c++ standard are You using in Your project ? - Reply to this email directly, view it on GitHub<#1 (comment)>, or unsubscribe<https://github.com/notifications/unsubscribe-auth/AFITVWPAGACVWPKUL2X3FPTYGBCSTAVCNFSM6AAAAAA7X7V7ESVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMYTQMRVGIZTQNRTGQ>. You are receiving this because you authored the thread.Message ID: ***@***.******@***.***>> // MIT License // // Copyright (c) 2020-2021 Artur Bac // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in all // copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. #pragma once #include <type_traits> #include <cstdint> #include <limits> #if __cplusplus > 201703L || _HAS_CXX20 #include <bit> #else #if defined(_MSC_VER) namespace std { // Implementation of countl_zero without using specialized CPU instructions. // Used at compile time and when said instructions are not supported. // see "Hacker's Delight" section 5-3 template <class _Ty> _NODISCARD constexpr int _Countl_zero_fallback(_Ty _Val) noexcept { _Ty _Yy = 0; unsigned int _Nn = numeric_limits<_Ty>::digits; unsigned int _Cc = numeric_limits<_Ty>::digits / 2; do { _Yy = static_cast<_Ty>(_Val >> _Cc); if (_Yy != 0) { _Nn -= _Cc; _Val = _Yy; } _Cc >>= 1; } while (_Cc != 0); return static_cast<int>(_Nn) - static_cast<int>(_Val); } // Implementation of countr_zero without using specialized CPU instructions. // Used at compile time and when said instructions are not supported. // see "Hacker's Delight" section 5-4 template <class _Ty> _NODISCARD constexpr int _Countr_zero_fallback(const _Ty _Val) noexcept { constexpr int _Digits = std::numeric_limits<_Ty>::digits; return _Digits - _Countl_zero_fallback(static_cast<_Ty>(static_cast<_Ty>(~_Val) & static_cast<_Ty>(_Val - 1))); } } #endif // #if defined(_MSC_VER) #endif namespace cxx20 { ///\brief Compare the values. negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion. template< class T, class U > constexpr bool cmp_equal( T t, U u ) noexcept { using UT = typename std::make_unsigned<T>::type; using UU = typename std::make_unsigned::type; if constexpr (std::is_signed<T>::value == std::is_signed::value) return t == u; else if constexpr (std::is_signed<T>::value) return t < 0 ? false : static_cast<UT>(t) == u; else return u < 0 ? false : t == static_cast<UU>(u); } ///\brief Compare the values. negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion. template< class T, class U > constexpr bool cmp_not_equal( T t, U u ) noexcept { return !cmp_equal(t, u); } ///\brief Compare the values. negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion. template< class T, class U > constexpr bool cmp_less( T t, U u ) noexcept { using UT = typename std::make_unsigned<T>::type; using UU = typename std::make_unsigned::type; if constexpr (std::is_signed<T>::value == std::is_signed::value ) return t < u; else if constexpr (std::is_signed<T>::value) return t < 0 ? true : static_cast<UT>(t) < u; else return u < 0 ? false : t < static_cast<UU>(u); } ///\brief Compare the values. negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion. template< class T, class U > constexpr bool cmp_greater( T t, U u ) noexcept { return cmp_less(u, t); } ///\brief Compare the values. negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion. template< class T, class U > constexpr bool cmp_less_equal( T t, U u ) noexcept { return !cmp_greater(t, u); } ///\brief Compare the values. negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion. template< class T, class U > constexpr bool cmp_greater_equal( T t, U u ) noexcept { return !cmp_less(t, u); } template<typename _Tp> using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<_Tp>::type>::type; template<typename _Tp> struct remove_cvref { using type = remove_cvref_t<_Tp>; }; template<typename T> constexpr int countl_zero(T value ) noexcept { static_assert(std::is_unsigned_v<T>); static_assert(std::is_integral<T>::value && sizeof(T) <= 8); #if __cplusplus > 201703L || _HAS_CXX20 return std::countl_zero(value); #elif defined(_MSC_VER) //msvc c++17 naive loop implementation return std::_Countl_zero_fallback(value); #else constexpr auto number_digits { std::numeric_limits<T>::digits }; if (value == 0) return number_digits; else { if constexpr (sizeof(T) < 4) { int lz{ __builtin_clz(value) }; return lz - 8 * (sizeof(int) - sizeof(T)); } else if constexpr (sizeof(T) == 4) return __builtin_clz(value); else if constexpr (sizeof(T) == 8) { if constexpr (sizeof(long) == 4) return __builtin_clzll(value); else return __builtin_clzl(value); } } #endif } static_assert( countl_zero(uint8_t(1)) == 8 - 1 ); static_assert( countl_zero(uint16_t(1)) == 16 - 1 ); static_assert(countl_zero(uint32_t{ 1 }) == 32 - 1); static_assert( countl_zero(uint32_t{ 2 }) == 32 - 2 ); static_assert( countl_zero(uint32_t{ 4 }) == 32 - 3 ); static_assert( countl_zero(uint64_t(4)) == 64 - 3 ); template<typename T> constexpr int countr_zero(T value ) noexcept { static_assert(std::is_unsigned_v<T>); #if defined(_MSC_VER) #if _HAS_CXX20 return std::countr_zero(value); #else return std::_Countr_zero(value); #endif #elif __cplusplus > 201703L || _HAS_CXX20 return std::countr_zero( value ); #else static_assert(std::is_integral<T>::value && sizeof(T)<=8); constexpr auto number_digits { std::numeric_limits<T>::digits }; if (value == 0) return number_digits; else { if constexpr( sizeof(T) < 4 ) { int lz{ __builtin_ctz( value ) }; return lz - 8 * (sizeof(int) - sizeof(T)); } else if constexpr( sizeof(T) == 4 ) return __builtin_ctz( value ); else if constexpr( sizeof(T) == 8 ) { if constexpr( sizeof(long) == 4 ) return __builtin_ctz( value ); else return __builtin_ctz( value ); } } #endif } } // MIT License // // Copyright (c) 2020-2021 Artur Bac // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in all // copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. #pragma once #if !defined(SMALL_VECTORS_CXX_UTILITY) #define SMALL_VECTORS_CXX_UTILITY 1 #include <type_traits> #include <cstdint> #include <limits> #include <memory> #include <utility> #if __cplusplus > 201703L || _HAS_CXX20 #include <bit> #include <concepts> #else #if defined(_MSC_VER) namespace std { // Implementation of countl_zero without using specialized CPU instructions. // Used at compile time and when said instructions are not supported. // see "Hacker's Delight" section 5-3 template <class _Ty> _NODISCARD constexpr int _Countl_zero_fallback(_Ty _Val) noexcept { _Ty _Yy = 0; unsigned int _Nn = numeric_limits<_Ty>::digits; unsigned int _Cc = numeric_limits<_Ty>::digits / 2; do { _Yy = static_cast<_Ty>(_Val >> _Cc); if (_Yy != 0) { _Nn -= _Cc; _Val = _Yy; } _Cc >>= 1; } while (_Cc != 0); return static_cast<int>(_Nn) - static_cast<int>(_Val); } // Implementation of countr_zero without using specialized CPU instructions. // Used at compile time and when said instructions are not supported. // see "Hacker's Delight" section 5-4 template <class _Ty> _NODISCARD constexpr int _Countr_zero_fallback(const _Ty _Val) noexcept { constexpr int _Digits = std::numeric_limits<_Ty>::digits; return _Digits - _Countl_zero_fallback(static_cast<_Ty>(static_cast<_Ty>(~_Val) & static_cast<_Ty>(_Val - 1))); } } #endif // #if defined(_MSC_VER) #endif // on linux depending on system build c++ standard libc++ version has various test macros undefined even for pure constexpr inline functions .. #if defined(_LIBCPP_STD_VER) && _LIBCPP_STD_VER >= 20 #if !defined(__cpp_lib_bitops) #define cpp_lib_bitops 201907L #endif #endif namespace cxx20 { #if defined(__cpp_lib_integer_comparison_functions) using std::cmp_equal; using std::cmp_not_equal; using std::cmp_less; using std::cmp_greater; using std::cmp_less_equal; using std::cmp_greater_equal; #else #if !defined(integer_comparison_functions_defiend) #define integer_comparison_functions_defiend ///\brief Compare the values. negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion. template< class T, class U > constexpr bool cmp_equal( T t, U u ) noexcept { using UT = typename std::make_unsigned<T>::type; using UU = typename std::make_unsigned::type; if constexpr (std::is_signed<T>::value == std::is_signed::value) return t == u; else if constexpr (std::is_signed<T>::value) return t < 0 ? false : static_cast<UT>(t) == u; else return u < 0 ? false : t == static_cast<UU>(u); } ///\brief Compare the values. negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion. template< class T, class U > constexpr bool cmp_not_equal( T t, U u ) noexcept { return !cmp_equal(t, u); } ///\brief Compare the values. negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion. template< class T, class U > constexpr bool cmp_less( T t, U u ) noexcept { using UT = typename std::make_unsigned<T>::type; using UU = typename std::make_unsigned::type; if constexpr (std::is_signed<T>::value == std::is_signed::value ) return t < u; else if constexpr (std::is_signed<T>::value) return t < 0 ? true : static_cast<UT>(t) < u; else return u < 0 ? false : t < static_cast<UU>(u); } ///\brief Compare the values. negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion. template< class T, class U > constexpr bool cmp_greater( T t, U u ) noexcept { return cmp_less(u, t); } ///\brief Compare the values. negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion. template< class T, class U > constexpr bool cmp_less_equal( T t, U u ) noexcept { return !cmp_greater(t, u); } ///\brief Compare the values. negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion. template< class T, class U > constexpr bool cmp_greater_equal( T t, U u ) noexcept { return !cmp_less(t, u); } #endif // integer_comparison_functions_defiend #endif // __cpp_lib_integer_comparison_functions #if defined(__cpp_lib_bitops) || defined(cpp_lib_bitops) using std::countr_zero; using std::countl_zero; #else template<typename T> constexpr int countl_zero(T value ) noexcept { static_assert(std::is_unsigned_v<T>); static_assert(std::is_integral<T>::value && sizeof(T) <= 8); #if defined(_MSC_VER) //msvc c++17 naive loop implementation return std::_Countl_zero_fallback(value); #else constexpr auto number_digits { std::numeric_limits<T>::digits }; if (value == 0) return number_digits; else { if constexpr (sizeof(T) < 4) { int lz{ __builtin_clz(value) }; return lz - 8 * (sizeof(int) - sizeof(T)); } else if constexpr (sizeof(T) == 4) return __builtin_clz(value); else if constexpr (sizeof(T) == 8) { if constexpr (sizeof(long) == 4) return __builtin_clzll(value); else return __builtin_clzl(value); } } #endif } static_assert( countl_zero(uint8_t(1)) == 8 - 1 ); static_assert( countl_zero(uint16_t(1)) == 16 - 1 ); static_assert(countl_zero(uint32_t{ 1 }) == 32 - 1); static_assert( countl_zero(uint32_t{ 2 }) == 32 - 2 ); static_assert( countl_zero(uint32_t{ 4 }) == 32 - 3 ); static_assert( countl_zero(uint64_t(4)) == 64 - 3 ); template<typename T> constexpr int countr_zero(T value ) noexcept { static_assert(std::is_unsigned_v<T>); static_assert(std::is_integral<T>::value && sizeof(T) <= 8); #if defined(_MSC_VER) return std::_Countr_zero(value); #else static_assert(std::is_integral<T>::value && sizeof(T)<=8); constexpr auto number_digits { std::numeric_limits<T>::digits }; if (value == 0) return number_digits; else { if constexpr( sizeof(T) < 4 ) { int lz{ __builtin_ctz( value ) }; return lz - 8 * (sizeof(int) - sizeof(T)); } else if constexpr( sizeof(T) == 4 ) return __builtin_ctz( value ); else if constexpr( sizeof(T) == 8 ) { if constexpr( sizeof(long) == 4 ) return __builtin_ctz( value ); else return __builtin_ctz( value ); } } #endif } #endif //__cpp_lib_bitops #if defined(__cpp_lib_bit_cast) using std::bit_cast; #else #if !__has_builtin(__builtin_bit_cast) #error "Not bit_cast support at all implement using std::memcpy" #endif template <class To, class From> #if __cplusplus > 201703L || _HAS_CXX20 requires requires(To, From) { sizeof(To) == sizeof(From); requires std::is_trivially_copyable_v<From>; requires std::is_trivially_copyable_v<To>; } #endif constexpr To bit_cast( From const & src) noexcept { #if __cplusplus <= 201703L static_assert(std::is_trivially_copyable_v<From>); static_assert(std::is_trivially_copyable_v<To>); #endif return __builtin_bit_cast(To,src); } #endif #if defined(__cpp_lib_assume_aligned) using std::assume_aligned; #else template< std::size_t N, class T > [[nodiscard]] constexpr T* assume_aligned(T* ptr) { #if __has_builtin(__builtin_assume_aligned) #if __cplusplus > 201703L || _HAS_CXX20 if( !std::is_constant_evaluated()) #endif return reinterpret_cast<T *>(__builtin_assume_aligned(ptr,N)); #if __cplusplus > 201703L || _HAS_CXX20 else return ptr; #endif #else return ptr; #endif } #endif } namespace cxx23 { #if defined(__cpp_lib_to_underlying) using std::to_underlying; #else template <class T> constexpr std::underlying_type_t<T> to_underlying( T value ) noexcept { return static_cast<std::underlying_type_t<T>>(value); } #endif #if defined(__cpp_lib_byteswap) using std::byteswap; #else // -O3 -std=c++20 //x86_64 // byteswap(unsigned long): # @byteswap(unsigned long) // mov rax, rdi // bswap rax // ret // byteswap(double): # @byteswap(double) // movq rax, xmm0 // bswap rax // movq xmm0, rax // ret //aarch64 // byteswap(unsigned long): // fmov d0, x0 // rev64 v0.8b, v0.8b // umov x0, v0.d[0] // ret // byteswap(double): // fmov x0, d0 // rev x0, x0 // fmov d0, x0 // ret // namespace detail { template<std::size_t sz, int32_t ix> struct swap_bytes_impl_t { [[gnu::always_inline]] static inline constexpr void swap( std::byte (&l)[sz] ) noexcept { swap_bytes_impl_t<sz,ix-1>::swap( l ); std::swap( l[ix], l[sz-1-ix]); } }; template<std::size_t sz> struct swap_bytes_impl_t<sz,0> { [[gnu::always_inline]] static inline constexpr void swap( std::byte (&l)[sz] ) noexcept { std::swap( l[0], l[sz-1]); } }; template<std::size_t sz> [[gnu::always_inline]] inline constexpr void swap_bytes(std::byte (&l)[sz]) noexcept { swap_bytes_impl_t<sz,sz/2-1>::swap(l); } #if __cplusplus > 201703L || _HAS_CXX20 template<typename T> concept trivially_copyable = std::is_trivially_copyable_v<T>; template<typename T> concept even_value_size = (sizeof(T) & 1) == 0; template<typename value_type> concept byte_swap_constraints = requires( value_type ) { requires detail::trivially_copyable<value_type>; requires detail::even_value_size<value_type>; }; #endif } #if __cplusplus > 201703L || _HAS_CXX20 template<detail::byte_swap_constraints value_type> #else template<typename value_type> #endif [[gnu::always_inline,gnu::const]] constexpr value_type byteswap( value_type big_or_le ) noexcept { #if __cplusplus <= 201703L static_assert(std::is_trivially_copyable_v<value_type>); static_assert((sizeof(value_type) & 1) == 0); #endif struct store_type { alignas(alignof(value_type)) std::byte data[sizeof(value_type)]; }; store_type raw { cxx20::bit_cast<store_type>(big_or_le) }; detail::swap_bytes(raw.data); return cxx20::bit_cast<value_type>(raw); } #endif } #endif //SMALL_VECTORS_CXX_UTILITY

Answer 4 · 2023-11-27T12:41:09.000Z

Thx.
Yep there were updates for c++20 and c++23 in library side functionalities, which doesn't affect fixed math functions at all.
So You are safe to revert for c++17, You will not lose anything.
I have to find more time to revert partial support for side functions back on msvc with c++17 in master.
Main project at which this lib is used already moved to c++20 that why I missed backward compatibility for msvc c++17.

Answer 5 · 2023-11-27T12:44:29.000Z

Btw it is good to know that actually someone else is using this library, so far I didn't know that at all, I'll keep this in mind.

Answer 6 · 2023-12-28T10:54:47.000Z

I fixed master v0.9.17 for using with c++17 masvc, when there is no bitcast support at all it will just not be available and compile with msvc c++17 mode, I can't implement it for msvc c++17 and it is not used in fixedmath at all, it is just side supported function I am using in some project with c++20/17 clang and fixedmath