az 1.2.1

Casts and checked casts
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

// Copyright © 2019–2021 Trevor Spiteri

// This library is free software: you can redistribute it and/or
// modify it under the terms of either
//
//   * the Apache License, Version 2.0 or
//   * the MIT License
//
// at your option.
//
// You should have recieved copies of the Apache License and the MIT
// License along with the library. If not, see
// <https://www.apache.org/licenses/LICENSE-2.0> and
// <https://opensource.org/licenses/MIT>.

use crate::{cast, checked_cast, unwrapped_cast};
use core::{f32, f64};

macro_rules! slice_to_float {
    ($vals: expr) => {
        for &val in $vals {
            if val != val {
                assert!(cast::<_, f32>(val).is_nan());
                assert!(checked_cast::<_, f32>(val).unwrap().is_nan());
                assert!(unwrapped_cast::<_, f32>(val).is_nan());
                assert!(cast::<_, f64>(val).is_nan());
                assert!(checked_cast::<_, f64>(val).unwrap().is_nan());
                assert!(unwrapped_cast::<_, f64>(val).is_nan());
            } else {
                assert_eq!(cast::<_, f32>(val), val as f32);
                assert_eq!(checked_cast::<_, f32>(val), Some(val as f32));
                assert_eq!(unwrapped_cast::<_, f32>(val), val as f32);
                assert_eq!(cast::<_, f64>(val), val as f64);
                assert_eq!(checked_cast::<_, f64>(val), Some(val as f64));
                assert_eq!(unwrapped_cast::<_, f64>(val), val as f64);
            }
        }
    };
}

#[test]
fn to_float() {
    let small_i = &[
        i8::min_value(),
        i8::min_value() + 1,
        -1,
        0,
        1,
        i8::max_value() - 1,
        i8::max_value(),
    ];
    let small_u = &[0, 1, u8::max_value() - 1, u8::max_value()];
    let small_f = &[
        0.0,
        f32::MIN_POSITIVE,
        1.0,
        1.5,
        2.0,
        f32::MAX,
        f32::INFINITY,
        f32::NAN,
    ];
    let big_i = &[
        i128::min_value(),
        i128::min_value() + 1,
        -1,
        0,
        1,
        i128::max_value() - 1,
        i128::max_value(),
    ];
    let big_u = &[0, 1, u128::max_value() - 1, u128::max_value()];
    let big_f = &[
        0.0,
        f64::MIN_POSITIVE,
        1.0,
        1.5,
        2.0,
        f64::MAX,
        f64::INFINITY,
        f64::NAN,
    ];

    slice_to_float!(small_i);
    slice_to_float!(small_u);
    slice_to_float!(small_f);
    slice_to_float!(big_i);
    slice_to_float!(big_u);
    slice_to_float!(big_f);
}

#[test]
fn specific_to_float() {
    // 0XFFFF_FE80 in 24 bits of precision becomes 0xFFFF_FE00
    assert_eq!(
        cast::<_, f32>(0xFFFF_FE80u32),
        (24f32.exp2() - 2.0) * 8f32.exp2()
    );
    // 0XFFFF_FE80..=0xFFFF_FF7F in 24 bits of precision become 0xFFFF_FF00
    assert_eq!(
        cast::<_, f32>(0xFFFF_FE81u32),
        (24f32.exp2() - 1.0) * 8f32.exp2()
    );
    assert_eq!(
        cast::<_, f32>(0xFFFF_FF00u32),
        (24f32.exp2() - 1.0) * 8f32.exp2()
    );
    assert_eq!(
        cast::<_, f32>(0xFFFF_FF7Fu32),
        (24f32.exp2() - 1.0) * 8f32.exp2()
    );
    // 0xFFFF_FF80 in 24 bits of precision becoms 0x1_0000_0000
    assert_eq!(cast::<_, f32>(0xFFFF_FF80u32), 24f32.exp2() * 8f32.exp2());
    assert_eq!(cast::<_, f32>(0xFFFF_FFFFu32), 24f32.exp2() * 8f32.exp2());

    // Same as above, but source is 128-bit instead of 32-bit.
    //   * (24f32.exp2() - 1.0) * 104f32.exp2() == f32::MAX
    //   * 24f32.exp2() * 104f32.exp2() > f32::MAX, overflows to f32::INFINITY
    assert_eq!(
        cast::<_, f32>(0xFFFF_FE80_0000_0000_0000_0000_0000_0000u128),
        (24f32.exp2() - 2.0) * 104f32.exp2()
    );
    assert_eq!(
        cast::<_, f32>(0xFFFF_FE80_0000_0000_0000_0000_0000_0001u128),
        f32::MAX
    );
    assert_eq!(
        cast::<_, f32>(0xFFFF_FF00_0000_0000_0000_0000_0000_0000u128),
        f32::MAX
    );
    assert_eq!(
        cast::<_, f32>(0xFFFF_FF7F_FFFF_FFFF_FFFF_FFFF_FFFF_FFFFu128),
        f32::MAX
    );
    assert_eq!(
        cast::<_, f32>(0xFFFF_FF80_0000_0000_0000_0000_0000_0000u128),
        f32::INFINITY
    );
    assert_eq!(
        cast::<_, f32>(0xFFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFFu128),
        f32::INFINITY
    );

    assert_eq!(cast::<_, f32>(f64::MAX), f32::INFINITY);
    assert_eq!(cast::<_, f32>(-f64::MAX), f32::NEG_INFINITY);
    assert_eq!(cast::<_, f32>(-f64::MAX), f32::NEG_INFINITY);
    assert_eq!(cast::<_, f32>(f64::from(f32::MAX) + 1.0), f32::MAX);
}