nstd_core 0.5.0

NSTD core crate.
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

/// Generates the abs function.
macro_rules! nstd_create_abs_fn {
    ($name: ident, $type: ty) => {
        #[inline]
        #[cfg_attr(feature = "clib", no_mangle)]
        pub unsafe extern "C" fn $name(x: $type) -> $type {
            x.abs()
        }
    };
}
nstd_create_abs_fn!(nstd_core_math_abs_i8, i8);
nstd_create_abs_fn!(nstd_core_math_abs_i16, i16);
nstd_create_abs_fn!(nstd_core_math_abs_i32, i32);
nstd_create_abs_fn!(nstd_core_math_abs_i64, i64);
nstd_create_abs_fn!(nstd_core_math_abs_isize, isize);

/// Generates the mod function.
macro_rules! nstd_create_mod_fn {
    ($name: ident, $type: ty) => {
        #[inline]
        #[cfg_attr(feature = "clib", no_mangle)]
        pub unsafe extern "C" fn $name(x: $type, y: $type) -> $type {
            x % y
        }
    };
}
nstd_create_mod_fn!(nstd_core_math_mod_f32, f32);
nstd_create_mod_fn!(nstd_core_math_mod_f64, f64);
nstd_create_mod_fn!(nstd_core_math_mod_u8, u8);
nstd_create_mod_fn!(nstd_core_math_mod_i8, i8);
nstd_create_mod_fn!(nstd_core_math_mod_u16, u16);
nstd_create_mod_fn!(nstd_core_math_mod_i16, i16);
nstd_create_mod_fn!(nstd_core_math_mod_u32, u32);
nstd_create_mod_fn!(nstd_core_math_mod_i32, i32);
nstd_create_mod_fn!(nstd_core_math_mod_u64, u64);
nstd_create_mod_fn!(nstd_core_math_mod_i64, i64);
nstd_create_mod_fn!(nstd_core_math_mod_usize, usize);
nstd_create_mod_fn!(nstd_core_math_mod_isize, isize);

/// Generates the max function.
macro_rules! nstd_create_max_fn {
    ($name: ident, $type: ty) => {
        #[inline]
        #[cfg_attr(feature = "clib", no_mangle)]
        pub unsafe extern "C" fn $name(x: $type, y: $type) -> $type {
            x.max(y)
        }
    };
}
nstd_create_max_fn!(nstd_core_math_max_f32, f32);
nstd_create_max_fn!(nstd_core_math_max_f64, f64);
nstd_create_max_fn!(nstd_core_math_max_u8, u8);
nstd_create_max_fn!(nstd_core_math_max_i8, i8);
nstd_create_max_fn!(nstd_core_math_max_u16, u16);
nstd_create_max_fn!(nstd_core_math_max_i16, i16);
nstd_create_max_fn!(nstd_core_math_max_u32, u32);
nstd_create_max_fn!(nstd_core_math_max_i32, i32);
nstd_create_max_fn!(nstd_core_math_max_u64, u64);
nstd_create_max_fn!(nstd_core_math_max_i64, i64);
nstd_create_max_fn!(nstd_core_math_max_usize, usize);
nstd_create_max_fn!(nstd_core_math_max_isize, isize);

/// Generates the min function.
macro_rules! nstd_create_min_fn {
    ($name: ident, $type: ty) => {
        #[inline]
        #[cfg_attr(feature = "clib", no_mangle)]
        pub unsafe extern "C" fn $name(x: $type, y: $type) -> $type {
            x.min(y)
        }
    };
}
nstd_create_min_fn!(nstd_core_math_min_f32, f32);
nstd_create_min_fn!(nstd_core_math_min_f64, f64);
nstd_create_min_fn!(nstd_core_math_min_u8, u8);
nstd_create_min_fn!(nstd_core_math_min_i8, i8);
nstd_create_min_fn!(nstd_core_math_min_u16, u16);
nstd_create_min_fn!(nstd_core_math_min_i16, i16);
nstd_create_min_fn!(nstd_core_math_min_u32, u32);
nstd_create_min_fn!(nstd_core_math_min_i32, i32);
nstd_create_min_fn!(nstd_core_math_min_u64, u64);
nstd_create_min_fn!(nstd_core_math_min_i64, i64);
nstd_create_min_fn!(nstd_core_math_min_usize, usize);
nstd_create_min_fn!(nstd_core_math_min_isize, isize);

/// Generates the pow function.
macro_rules! nstd_create_pow_fn {
    ($name: ident, $type: ty) => {
        #[inline]
        #[cfg_attr(feature = "clib", no_mangle)]
        pub unsafe extern "C" fn $name(x: $type, y: u32) -> $type {
            x.wrapping_pow(y)
        }
    };
}
nstd_create_pow_fn!(nstd_core_math_pow_u8, u8);
nstd_create_pow_fn!(nstd_core_math_pow_i8, i8);
nstd_create_pow_fn!(nstd_core_math_pow_u16, u16);
nstd_create_pow_fn!(nstd_core_math_pow_i16, i16);
nstd_create_pow_fn!(nstd_core_math_pow_u32, u32);
nstd_create_pow_fn!(nstd_core_math_pow_i32, i32);
nstd_create_pow_fn!(nstd_core_math_pow_u64, u64);
nstd_create_pow_fn!(nstd_core_math_pow_i64, i64);
nstd_create_pow_fn!(nstd_core_math_pow_usize, usize);
nstd_create_pow_fn!(nstd_core_math_pow_isize, isize);

/// Generates the clamp function.
macro_rules! nstd_create_clamp_fn {
    ($name: ident, $type: ty) => {
        #[inline]
        #[cfg_attr(feature = "clib", no_mangle)]
        pub unsafe extern "C" fn $name(value: $type, min: $type, max: $type) -> $type {
            if value < min {
                min
            } else if value > max {
                max
            } else {
                value
            }
        }
    };
}
nstd_create_clamp_fn!(nstd_core_math_clamp_f32, f32);
nstd_create_clamp_fn!(nstd_core_math_clamp_f64, f64);
nstd_create_clamp_fn!(nstd_core_math_clamp_u8, u8);
nstd_create_clamp_fn!(nstd_core_math_clamp_i8, i8);
nstd_create_clamp_fn!(nstd_core_math_clamp_u16, u16);
nstd_create_clamp_fn!(nstd_core_math_clamp_i16, i16);
nstd_create_clamp_fn!(nstd_core_math_clamp_u32, u32);
nstd_create_clamp_fn!(nstd_core_math_clamp_i32, i32);
nstd_create_clamp_fn!(nstd_core_math_clamp_u64, u64);
nstd_create_clamp_fn!(nstd_core_math_clamp_i64, i64);
nstd_create_clamp_fn!(nstd_core_math_clamp_usize, usize);
nstd_create_clamp_fn!(nstd_core_math_clamp_isize, isize);