jiao 0.4.1

Cross platform 2D graphics library
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

// Copyright (c) 2023 Xu Shaohua <shaohua@biofan.org>. All rights reserved.
// Use of this source is governed by Lesser General Public License that can be found
// in the LICENSE file.

#![allow(clippy::cast_possible_truncation)]

pub const MAX_I32_FITS_IN_F32: i32 = 2_147_483_520;
#[allow(clippy::cast_precision_loss)]
pub const MAX_I32_FITS_IN_F32_F32: f32 = MAX_I32_FITS_IN_F32 as f32;
pub const MIN_I32_FITS_IN_F32: i32 = -MAX_I32_FITS_IN_F32;
#[allow(clippy::cast_precision_loss)]
pub const MIN_I32_FITS_IN_F32_F32: f32 = MIN_I32_FITS_IN_F32 as f32;

// 0x7fffff8000000000
pub const MAX_I64_FITS_IN_F32: i64 = i64::MAX >> (63 - 24) << (63 - 24);
#[allow(clippy::cast_precision_loss)]
pub const MAX_I64_FITS_IN_F32_F32: f32 = MAX_I64_FITS_IN_F32 as f32;
pub const MIN_I64_FITS_IN_F32: i64 = -MAX_I64_FITS_IN_F32;
#[allow(clippy::cast_precision_loss)]
pub const MIN_I64_FITS_IN_F32_F32: f32 = MIN_I64_FITS_IN_F32 as f32;

/// Return the closest int for the given float.
///
/// Returns `MAX_I32_FITS_IN_F32` for NaN.
#[must_use]
pub fn f32_saturate2int(mut x: f32) -> i32 {
    x = if x < MAX_I32_FITS_IN_F32_F32 {
        x
    } else {
        MAX_I32_FITS_IN_F32_F32
    };
    x = if x > MIN_I32_FITS_IN_F32_F32 {
        x
    } else {
        MIN_I32_FITS_IN_F32_F32
    };
    x as i32
}

/// Return the closest int for the given double.
///
/// Returns `i32::MAX` for NaN.
pub fn f64_saturate2int(mut x: f64) -> i32 {
    x = if x < i32::MAX.into() {
        x
    } else {
        i32::MAX.into()
    };
    x = if x > i32::MIN.into() {
        x
    } else {
        i32::MIN.into()
    };
    x as i32
}

/// Return the closest i64 for the given float.
///
/// Returns `MAX_I64_FITS_IN_F32` for NaN.
pub fn f32_saturate2int64(mut x: f32) -> i64 {
    x = if x < MAX_I64_FITS_IN_F32_F32 {
        x
    } else {
        MAX_I64_FITS_IN_F32_F32
    };
    x = if x > MIN_I64_FITS_IN_F32_F32 {
        x
    } else {
        MIN_I64_FITS_IN_F32_F32
    };
    x as i64
}

#[must_use]
pub fn f32_floor2int(x: f32) -> i32 {
    f32_saturate2int(x.floor())
}

#[must_use]
pub fn f32_round2int(x: f32) -> i32 {
    f32_saturate2int(x.round())
}

#[must_use]
pub fn f32_ceil2int(x: f32) -> i32 {
    f32_saturate2int(x.ceil())
}

/// Calculate the midpoint between a and b.
///
/// Similar to `std::midpoint` in c++20.
pub fn f32_midpoint(a: f32, b: f32) -> f32 {
    let a = f64::from(a);
    let b = f64::from(b);
    // Use f64 math to avoid underflow and overflow.
    (0.5 * (a + b)) as f32
}

/// Returns false if any of the floats are outside the range [0...1].
///
/// Returns true if count is 0.
pub fn floats_are_unit(_array: &[f32]) -> bool {
    unimplemented!()
}

/// Returns true iff the provided number is within a small epsilon of 0.
#[must_use]
pub fn f64_nearly_zero(_a: f64) -> bool {
    unimplemented!()
}

/// Compare two doubles and return true if they are within `max_ulps_diff` of each other.
///
/// - nan as a or b - returns false.
/// - infinity, infinity or -infinity, -infinity - returns true.
/// - infinity and any other number - returns false.
///
/// ulp is an initialism for Units in the Last Place.
#[must_use]
#[inline]
pub fn doubles_nearly_equal_ulps(_a: f64, _b: f64, _max_ulps_diff: u8) -> bool {
    unimplemented!()
}

#[must_use]
#[inline]
pub fn doubles_nearly_equal(a: f64, b: f64) -> bool {
    doubles_nearly_equal_ulps(a, b, 16)
}