Skip to content

Commit 11b03ff

Browse files
danakjdanakj
committed
Define float to integer bit casts to convert to the nearest value
/// Casting from a float to an integer will round the float towards zero, except: /// * NaN will return 0. /// * Values larger than the maximum integer value, including INFINITY, will /// saturate to the maximum value of the integer type. /// * Values smaller than the minimum integer value, including NEG_INFINITY, /// will saturate to the minimum value of the integer type.
1 parent 1138d18 commit 11b03ff

File tree

2 files changed

+259
-84
lines changed

2 files changed

+259
-84
lines changed

‎subspace/num/convert.h

Lines changed: 77 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,13 @@
2222
#include "subspace/num/signed_integer.h"
2323
#include "subspace/num/unsigned_integer.h"
2424

25+
/// Casting from a float to an integer will round the float towards zero, except:
26+
/// * NaN will return 0.
27+
/// * Values larger than the maximum integer value, including `INFINITY`, will
28+
/// saturate to the maximum value of the integer type.
29+
/// * Values smaller than the minimum integer value, including `NEG_INFINITY`,
30+
/// will saturate to the minimum value of the integer type.
31+
2532
// # ================ From signed integers. ============================
2633

2734
// ## === Into `Integer`
@@ -98,7 +105,74 @@ struct sus::construct::ToBitsImpl<T, std::byte> {
98105
template <sus::num::PrimitiveInteger T, sus::num::Float F>
99106
struct sus::construct::ToBitsImpl<T, F> {
100107
constexpr static T from_bits(const F& from) noexcept {
101-
return ::sus::to_bits<T>(from.primitive_value);
108+
if (from.is_nan()) return T(0);
109+
110+
struct MinMax {
111+
F min, max;
112+
};
113+
constexpr MinMax minmax = []() {
114+
if constexpr (::sus::mem::size_of<T>() == 1u) {
115+
if constexpr (std::is_signed_v<T>) {
116+
if constexpr (::sus::mem::size_of<F>() == 4u) {
117+
return MinMax(-128.f, 127.f);
118+
} else {
119+
return MinMax(-128.0, 127.0);
120+
}
121+
} else {
122+
if constexpr (::sus::mem::size_of<F>() == 4u) {
123+
return MinMax(0.f, 255.f);
124+
} else {
125+
return MinMax(0.0, 255.0);
126+
}
127+
}
128+
} else if constexpr (::sus::mem::size_of<T>() == 2u) {
129+
if constexpr (std::is_signed_v<T>) {
130+
if constexpr (::sus::mem::size_of<F>() == 4u) {
131+
return MinMax(-32768.f, 32767.f);
132+
} else {
133+
return MinMax(-32768.0, 32767.0);
134+
}
135+
} else {
136+
if constexpr (::sus::mem::size_of<F>() == 4u) {
137+
return MinMax(0.f, 65535.f);
138+
} else {
139+
return MinMax(0.0, 65535.0);
140+
}
141+
}
142+
} else if constexpr (::sus::mem::size_of<T>() == 4u) {
143+
if constexpr (std::is_signed_v<T>) {
144+
if constexpr (::sus::mem::size_of<F>() == 4u) {
145+
return MinMax(-2147483648.f, 2147483647.f);
146+
} else {
147+
return MinMax(-2147483648.0, 2147483647.0);
148+
}
149+
} else {
150+
if constexpr (::sus::mem::size_of<F>() == 4u) {
151+
return MinMax(0.f, 4294967295.f);
152+
} else {
153+
return MinMax(0.0, 4294967295.0);
154+
}
155+
}
156+
} else {
157+
static_assert(::sus::mem::size_of<T>() == 8u);
158+
if constexpr (std::is_signed_v<T>) {
159+
if constexpr (::sus::mem::size_of<F>() == 4u) {
160+
return MinMax(-9223372036854775808.f, 9223372036854775807.f);
161+
} else {
162+
return MinMax(-9223372036854775808.0, 9223372036854775807.0);
163+
}
164+
} else {
165+
if constexpr (::sus::mem::size_of<F>() == 4u) {
166+
return MinMax(0.f, 18446744073709551615.f);
167+
} else {
168+
return MinMax(0.0, 18446744073709551615.0);
169+
}
170+
}
171+
}
172+
}();
173+
if (from >= minmax.max) return ::sus::num::__private::max_value<T>();
174+
if (from <= minmax.min) return ::sus::num::__private::min_value<T>();
175+
return static_cast<T>(from.primitive_value);
102176
}
103177
};
104178

@@ -107,12 +181,10 @@ template <sus::num::PrimitiveInteger T, sus::num::PrimitiveFloat F>
107181
struct sus::construct::ToBitsImpl<T, F> {
108182
constexpr static T from_bits(const F& from) noexcept {
109183
if constexpr (::sus::mem::size_of<F>() == 4u) {
110-
return static_cast<T>(
111-
static_cast<std::make_unsigned_t<T>>(std::bit_cast<uint32_t>(from)));
184+
return ::sus::to_bits<T>(::sus::num::f32(from));
112185
} else {
113186
static_assert(::sus::mem::size_of<F>() == 8u);
114-
return static_cast<T>(
115-
static_cast<std::make_unsigned_t<T>>(std::bit_cast<uint64_t>(from)));
187+
return ::sus::to_bits<T>(::sus::num::f64(from));
116188
}
117189
}
118190
};

‎subspace/num/convert_unittest.cc

Lines changed: 182 additions & 79 deletions
Original file line numberDiff line numberDiff line change
@@ -355,99 +355,202 @@ TEST(ConvertToBits, isize) {
355355
}
356356

357357
TEST(ConvertToBits, f32) {
358-
// Bit value 0b1100'0000'0101'0101'1101'0101'0000'1110.
359-
constexpr auto v = -3.34112882614_f32;
358+
static_assert(std::same_as<decltype(sus::to_bits<u16>(0_f32)), u16>);
360359

361360
// Float to smaller unsigned.
362361
{
363-
auto i = sus::to_bits<u16>(v);
364-
static_assert(std::same_as<decltype(i), u16>);
365-
EXPECT_EQ(i, 0b1101'0101'0000'1110_u16);
366-
auto f = sus::to_bits<f32>(i);
367-
EXPECT_EQ(f, 7.64296208412e-41_f32);
368-
}
369-
// Float to larger unsigned.
370-
{
371-
auto i = sus::to_bits<u64>(v);
372-
static_assert(std::same_as<decltype(i), u64>);
373-
EXPECT_EQ(i, 0b1100'0000'0101'0101'1101'0101'0000'1110);
374-
auto f = sus::to_bits<f32>(i);
375-
EXPECT_EQ(f, v);
362+
EXPECT_EQ(sus::to_bits<u16>(f32::NAN), 0_u16);
363+
364+
EXPECT_EQ(sus::to_bits<u16>(0_f32), u16::MIN);
365+
EXPECT_EQ(sus::to_bits<u16>(-0_f32), u16::MIN);
366+
EXPECT_EQ(sus::to_bits<u16>(-0.00001_f32), u16::MIN);
367+
EXPECT_EQ(sus::to_bits<u16>(-99999999_f32), u16::MIN);
368+
EXPECT_EQ(sus::to_bits<u16>(f32::NEG_INFINITY), u16::MIN);
369+
370+
EXPECT_EQ(sus::to_bits<u16>(0.1_f32), 0_u16);
371+
EXPECT_EQ(sus::to_bits<u16>(0.51_f32), 0_u16);
372+
EXPECT_EQ(sus::to_bits<u16>(0.9999_f32), 0_u16);
373+
EXPECT_EQ(sus::to_bits<u16>(1_f32), 1_u16);
374+
EXPECT_EQ(sus::to_bits<u16>(65535_f32), u16::MAX);
375+
EXPECT_EQ(sus::to_bits<u16>(65535.00001_f32), u16::MAX);
376+
EXPECT_EQ(sus::to_bits<u16>(65536_f32), u16::MAX);
377+
EXPECT_EQ(sus::to_bits<u16>(999999999_f32), u16::MAX);
378+
EXPECT_EQ(sus::to_bits<u16>(f32::INFINITY), u16::MAX);
376379
}
377380
// Float to smaller signed.
378381
{
379-
auto i = sus::to_bits<i16>(v);
380-
static_assert(std::same_as<decltype(i), i16>);
381-
EXPECT_EQ(i, sus::to_bits<i16>(0b1101'0101'0000'1110_u16));
382-
EXPECT_EQ(i, -10994);
383-
auto f = sus::to_bits<f32>(i);
384-
EXPECT_EQ(f, 7.64296208412e-41_f32);
382+
EXPECT_EQ(sus::to_bits<i16>(f32::NAN), 0_i16);
383+
384+
EXPECT_EQ(sus::to_bits<i16>(0_f32), 0_i16);
385+
EXPECT_EQ(sus::to_bits<i16>(-0_f32), 0_i16);
386+
EXPECT_EQ(sus::to_bits<i16>(-0.00001_f32), 0_i16);
387+
EXPECT_EQ(sus::to_bits<i16>(-0.9999_f32), 0_i16);
388+
EXPECT_EQ(sus::to_bits<i16>(-1_f32), -1_i16);
389+
EXPECT_EQ(sus::to_bits<i16>(-32767.999_f32), -32767_i16);
390+
EXPECT_EQ(sus::to_bits<i16>(-32768_f32), i16::MIN);
391+
EXPECT_EQ(sus::to_bits<i16>(-32768.00001_f32), i16::MIN);
392+
EXPECT_EQ(sus::to_bits<i16>(-99999999_f32), i16::MIN);
393+
EXPECT_EQ(sus::to_bits<i16>(f32::NEG_INFINITY), i16::MIN);
394+
395+
EXPECT_EQ(sus::to_bits<i16>(0.1_f32), 0_i16);
396+
EXPECT_EQ(sus::to_bits<i16>(0.51_f32), 0_i16);
397+
EXPECT_EQ(sus::to_bits<i16>(0.9999_f32), 0_i16);
398+
EXPECT_EQ(sus::to_bits<i16>(1_f32), 1_i16);
399+
EXPECT_EQ(sus::to_bits<i16>(32767.999_f32), i16::MAX);
400+
EXPECT_EQ(sus::to_bits<i16>(32767.00001_f32), i16::MAX);
401+
EXPECT_EQ(sus::to_bits<i16>(32767_f32), i16::MAX);
402+
EXPECT_EQ(sus::to_bits<i16>(999999999_f32), i16::MAX);
403+
EXPECT_EQ(sus::to_bits<i16>(f32::INFINITY), i16::MAX);
385404
}
386-
// Float to larger signed.
405+
406+
// Float to larger unsigned.
387407
{
388-
auto i = sus::to_bits<i64>(v);
389-
static_assert(std::same_as<decltype(i), i64>);
390-
EXPECT_EQ(i, sus::to_bits<i64>(0b1100'0000'0101'0101'1101'0101'0000'1110));
391-
EXPECT_EQ(i, 3226850574);
392-
auto f = sus::to_bits<f32>(i);
393-
EXPECT_EQ(f, v);
408+
EXPECT_EQ(sus::to_bits<u64>(f32::NAN), 0_u64);
409+
410+
EXPECT_EQ(sus::to_bits<u64>(0_f32), u64::MIN);
411+
EXPECT_EQ(sus::to_bits<u64>(-0_f32), u64::MIN);
412+
EXPECT_EQ(sus::to_bits<u64>(-0.00001_f32), u64::MIN);
413+
EXPECT_EQ(sus::to_bits<u64>(-99999999_f32), u64::MIN);
414+
EXPECT_EQ(sus::to_bits<u64>(f32::NEG_INFINITY), u64::MIN);
415+
416+
EXPECT_EQ(sus::to_bits<u64>(0.1_f32), 0_u64);
417+
EXPECT_EQ(sus::to_bits<u64>(0.51_f32), 0_u64);
418+
EXPECT_EQ(sus::to_bits<u64>(0.9999_f32), 0_u64);
419+
EXPECT_EQ(sus::to_bits<u64>(1_f32), 1_u64);
420+
EXPECT_LT(sus::to_bits<u64>((18446744073709551615_f32).next_toward(0_f32)),
421+
u64::MAX);
422+
EXPECT_EQ(sus::to_bits<u64>(18446744073709551615_f32), u64::MAX);
423+
EXPECT_EQ(sus::to_bits<u64>(18446744073709551615.00001_f32), u64::MAX);
424+
EXPECT_EQ(sus::to_bits<u64>(18446744073709551615_f32 + 1_f32), u64::MAX);
425+
EXPECT_EQ(sus::to_bits<u64>(18446744073709551615_f32 * 2_f32), u64::MAX);
426+
EXPECT_EQ(sus::to_bits<u64>(f32::INFINITY), u64::MAX);
394427
}
395-
// Float to double.
428+
// Float to larger signed.
396429
{
397-
auto i = sus::to_bits<f64>(v);
398-
static_assert(std::same_as<decltype(i), f64>);
399-
EXPECT_EQ(i, 1.59427601287650712395167736662e-314_f64);
400-
auto f = sus::to_bits<f32>(i);
401-
EXPECT_EQ(f, v);
430+
EXPECT_EQ(sus::to_bits<i64>(f32::NAN), 0_i64);
431+
432+
EXPECT_EQ(sus::to_bits<i64>(0_f32), 0_i64);
433+
EXPECT_EQ(sus::to_bits<i64>(-0_f32), 0_i64);
434+
EXPECT_EQ(sus::to_bits<i64>(-0.00001_f32), 0_i64);
435+
EXPECT_EQ(sus::to_bits<i64>(-0.9999_f32), 0_i64);
436+
EXPECT_EQ(sus::to_bits<i64>(-1_f32), -1_i64);
437+
EXPECT_GT(sus::to_bits<i64>((-9223372036854775808_f32).next_toward(0_f32)),
438+
i64::MIN);
439+
EXPECT_EQ(sus::to_bits<i64>(-9223372036854775808_f32), i64::MIN);
440+
EXPECT_EQ(sus::to_bits<i64>(-9223372036854775808.00001_f32), i64::MIN);
441+
EXPECT_EQ(sus::to_bits<i64>(-9999999999999999999_f32), i64::MIN);
442+
EXPECT_EQ(sus::to_bits<i64>(f32::NEG_INFINITY), i64::MIN);
443+
444+
EXPECT_EQ(sus::to_bits<i64>(0.1_f32), 0_i64);
445+
EXPECT_EQ(sus::to_bits<i64>(0.51_f32), 0_i64);
446+
EXPECT_EQ(sus::to_bits<i64>(0.9999_f32), 0_i64);
447+
EXPECT_EQ(sus::to_bits<i64>(1_f32), 1_i64);
448+
EXPECT_LT(sus::to_bits<i64>((9223372036854775807_f32).next_toward(0_f32)),
449+
i64::MAX);
450+
EXPECT_EQ(sus::to_bits<i64>(9223372036854775807_f32), i64::MAX);
451+
EXPECT_EQ(sus::to_bits<i64>(92233720368547758075.00001_f32), i64::MAX);
452+
EXPECT_EQ(sus::to_bits<i64>(9223372036854775808_f32), i64::MAX);
453+
EXPECT_EQ(sus::to_bits<i64>(9999999999999999999_f32), i64::MAX);
454+
EXPECT_EQ(sus::to_bits<i64>(f32::INFINITY), i64::MAX);
402455
}
403456
}
404457

405458
TEST(ConvertToBits, f64) {
406-
// Bit value
407-
// 0b10101000'10101010'10101010'00101010'10101000'10101010'10101110'11101110.
408-
constexpr auto v = -8.66220694718676082014277885371e-113_f64;
409-
410-
// Double to smaller unsigned.
411-
{
412-
auto i = sus::to_bits<u16>(v);
413-
static_assert(std::same_as<decltype(i), u16>);
414-
EXPECT_EQ(i, 0b10101110'11101110_u16);
415-
auto f = sus::to_bits<f64>(i);
416-
EXPECT_EQ(f, 2.21252477520627027413151036822e-319_f64);
417-
}
418-
// Double to unsigned.
419-
{
420-
auto i = sus::to_bits<u64>(v);
421-
static_assert(std::same_as<decltype(i), u64>);
422-
EXPECT_EQ(i, 0b10101000'10101010'10101010'00101010'10101000'10101010'10101110'11101110_u64);
423-
auto f = sus::to_bits<f64>(i);
424-
EXPECT_EQ(f, v);
425-
}
426-
// Double to smaller signed.
427-
{
428-
auto i = sus::to_bits<i16>(v);
429-
static_assert(std::same_as<decltype(i), i16>);
430-
EXPECT_EQ(i, sus::to_bits<i16>(0b10101110'11101110_u16));
431-
EXPECT_EQ(i, -20754);
432-
auto f = sus::to_bits<f64>(i);
433-
EXPECT_EQ(f, 2.21252477520627027413151036822e-319_f64);
434-
}
435-
// Double to signed.
436-
{
437-
auto i = sus::to_bits<i64>(v);
438-
static_assert(std::same_as<decltype(i), i64>);
439-
EXPECT_EQ(i, sus::to_bits<i64>(0b10101000'10101010'10101010'00101010'10101000'10101010'10101110'11101110_u64));
440-
EXPECT_EQ(i, -6293030429101740306);
441-
auto f = sus::to_bits<f64>(i);
442-
EXPECT_EQ(f, v);
443-
}
444-
// Double to float.
445-
{
446-
auto i = sus::to_bits<f32>(v);
447-
static_assert(std::same_as<decltype(i), f32>);
448-
EXPECT_EQ(i, -1.89496550775e-14_f32);
449-
auto f = sus::to_bits<f64>(i);
450-
EXPECT_EQ(f, 1.39808630771690684819284234772e-314_f64);
459+
static_assert(std::same_as<decltype(sus::to_bits<u16>(0_f64)), u16>);
460+
461+
// Float to smaller unsigned.
462+
{
463+
EXPECT_EQ(sus::to_bits<u16>(f64::NAN), 0_u16);
464+
465+
EXPECT_EQ(sus::to_bits<u16>(0_f64), u16::MIN);
466+
EXPECT_EQ(sus::to_bits<u16>(-0_f64), u16::MIN);
467+
EXPECT_EQ(sus::to_bits<u16>(-0.00001_f64), u16::MIN);
468+
EXPECT_EQ(sus::to_bits<u16>(-99999999_f64), u16::MIN);
469+
EXPECT_EQ(sus::to_bits<u16>(f64::NEG_INFINITY), u16::MIN);
470+
471+
EXPECT_EQ(sus::to_bits<u16>(0.1_f64), 0_u16);
472+
EXPECT_EQ(sus::to_bits<u16>(0.51_f64), 0_u16);
473+
EXPECT_EQ(sus::to_bits<u16>(0.9999_f64), 0_u16);
474+
EXPECT_EQ(sus::to_bits<u16>(1_f64), 1_u16);
475+
EXPECT_EQ(sus::to_bits<u16>(65535_f64), u16::MAX);
476+
EXPECT_EQ(sus::to_bits<u16>(65535.00001_f64), u16::MAX);
477+
EXPECT_EQ(sus::to_bits<u16>(65536_f64), u16::MAX);
478+
EXPECT_EQ(sus::to_bits<u16>(999999999_f64), u16::MAX);
479+
EXPECT_EQ(sus::to_bits<u16>(f64::INFINITY), u16::MAX);
480+
}
481+
// Float to smaller signed.
482+
{
483+
EXPECT_EQ(sus::to_bits<i16>(f64::NAN), 0_i16);
484+
485+
EXPECT_EQ(sus::to_bits<i16>(0_f64), 0_i16);
486+
EXPECT_EQ(sus::to_bits<i16>(-0_f64), 0_i16);
487+
EXPECT_EQ(sus::to_bits<i16>(-0.00001_f64), 0_i16);
488+
EXPECT_EQ(sus::to_bits<i16>(-0.9999_f64), 0_i16);
489+
EXPECT_EQ(sus::to_bits<i16>(-1_f64), -1_i16);
490+
EXPECT_EQ(sus::to_bits<i16>(-32767.999_f64), -32767_i16);
491+
EXPECT_EQ(sus::to_bits<i16>(-32768_f64), i16::MIN);
492+
EXPECT_EQ(sus::to_bits<i16>(-32768.00001_f64), i16::MIN);
493+
EXPECT_EQ(sus::to_bits<i16>(-99999999_f64), i16::MIN);
494+
EXPECT_EQ(sus::to_bits<i16>(f64::NEG_INFINITY), i16::MIN);
495+
496+
EXPECT_EQ(sus::to_bits<i16>(0.1_f64), 0_i16);
497+
EXPECT_EQ(sus::to_bits<i16>(0.51_f64), 0_i16);
498+
EXPECT_EQ(sus::to_bits<i16>(0.9999_f64), 0_i16);
499+
EXPECT_EQ(sus::to_bits<i16>(1_f64), 1_i16);
500+
EXPECT_EQ(sus::to_bits<i16>(65535_f64), i16::MAX);
501+
EXPECT_EQ(sus::to_bits<i16>(65535.00001_f64), i16::MAX);
502+
EXPECT_EQ(sus::to_bits<i16>(65536_f64), i16::MAX);
503+
EXPECT_EQ(sus::to_bits<i16>(999999999_f64), i16::MAX);
504+
EXPECT_EQ(sus::to_bits<i16>(f64::INFINITY), i16::MAX);
505+
}
506+
507+
// Float to unsigned.
508+
{
509+
EXPECT_EQ(sus::to_bits<u64>(f64::NAN), 0_u64);
510+
511+
EXPECT_EQ(sus::to_bits<u64>(0_f64), u64::MIN);
512+
EXPECT_EQ(sus::to_bits<u64>(-0_f64), u64::MIN);
513+
EXPECT_EQ(sus::to_bits<u64>(-0.00001_f64), u64::MIN);
514+
EXPECT_EQ(sus::to_bits<u64>(-99999999_f64), u64::MIN);
515+
EXPECT_EQ(sus::to_bits<u64>(f64::NEG_INFINITY), u64::MIN);
516+
517+
EXPECT_EQ(sus::to_bits<u64>(0.1_f64), 0_u64);
518+
EXPECT_EQ(sus::to_bits<u64>(0.51_f64), 0_u64);
519+
EXPECT_EQ(sus::to_bits<u64>(0.9999_f64), 0_u64);
520+
EXPECT_EQ(sus::to_bits<u64>(1_f64), 1_u64);
521+
EXPECT_LT(sus::to_bits<u64>((18446744073709551615_f64).next_toward(0_f64)),
522+
u64::MAX);
523+
EXPECT_EQ(sus::to_bits<u64>(18446744073709551615_f64), u64::MAX);
524+
EXPECT_EQ(sus::to_bits<u64>(18446744073709551615.00001_f64), u64::MAX);
525+
EXPECT_EQ(sus::to_bits<u64>(18446744073709551615_f64 + 1_f64), u64::MAX);
526+
EXPECT_EQ(sus::to_bits<u64>(18446744073709551615_f64 * 2_f64), u64::MAX);
527+
EXPECT_EQ(sus::to_bits<u64>(f64::INFINITY), u64::MAX);
528+
}
529+
// Float to signed.
530+
{
531+
EXPECT_EQ(sus::to_bits<i64>(f64::NAN), 0_i64);
532+
533+
EXPECT_EQ(sus::to_bits<i64>(0_f64), 0_i64);
534+
EXPECT_EQ(sus::to_bits<i64>(-0_f64), 0_i64);
535+
EXPECT_EQ(sus::to_bits<i64>(-0.00001_f64), 0_i64);
536+
EXPECT_EQ(sus::to_bits<i64>(-0.9999_f64), 0_i64);
537+
EXPECT_EQ(sus::to_bits<i64>(-1_f64), -1_i64);
538+
EXPECT_GT(sus::to_bits<i64>((-9223372036854775808_f64).next_toward(0_f64)),
539+
i64::MIN);
540+
EXPECT_EQ(sus::to_bits<i64>(-9223372036854775808_f64), i64::MIN);
541+
EXPECT_EQ(sus::to_bits<i64>(-9223372036854775808.00001_f64), i64::MIN);
542+
EXPECT_EQ(sus::to_bits<i64>(-9223372036854775808_f64 * 2_f64), i64::MIN);
543+
EXPECT_EQ(sus::to_bits<i64>(f64::NEG_INFINITY), i64::MIN);
544+
545+
EXPECT_EQ(sus::to_bits<i64>(0.1_f64), 0_i64);
546+
EXPECT_EQ(sus::to_bits<i64>(0.51_f64), 0_i64);
547+
EXPECT_EQ(sus::to_bits<i64>(0.9999_f64), 0_i64);
548+
EXPECT_EQ(sus::to_bits<i64>(1_f64), 1_i64);
549+
EXPECT_LT(sus::to_bits<i64>((9223372036854775807_f64).next_toward(0_f64)), i64::MAX);
550+
EXPECT_EQ(sus::to_bits<i64>(9223372036854775807_f64), i64::MAX);
551+
EXPECT_EQ(sus::to_bits<i64>(9223372036854775807.00001_f64), i64::MAX);
552+
EXPECT_EQ(sus::to_bits<i64>(9223372036854775807_f64 * 2_f64), i64::MAX);
553+
EXPECT_EQ(sus::to_bits<i64>(f64::INFINITY), i64::MAX);
451554
}
452555
}
453556

0 commit comments

Comments
 (0)