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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
//! Algorithms for single words (u8...u64).

mod to_word;

pub use bitintr::Int as Word;

pub use self::to_word::*;

mod count_zeros;
pub use self::count_zeros::*;

mod count_ones;
pub use self::count_ones::*;

mod count_leading_zeros;
pub use self::count_leading_zeros::*;

mod count_leading_ones;
pub use self::count_leading_ones::*;

mod count_trailing_zeros;
pub use self::count_trailing_zeros::*;

mod count_trailing_ones;
pub use self::count_trailing_ones::*;

mod shift_logical_left;
pub use self::shift_logical_left::*;

mod shift_logical_right;
pub use self::shift_logical_right::*;

mod shift_arithmetic_left;
pub use self::shift_arithmetic_left::*;

mod shift_arithmetic_right;
pub use self::shift_arithmetic_right::*;

mod rotate_left;
pub use self::rotate_left::*;

mod rotate_right;
pub use self::rotate_right::*;

mod swap_bytes;
pub use self::swap_bytes::*;

mod from_be;
pub use self::from_be::*;

mod from_le;
pub use self::from_le::*;

mod to_be;
pub use self::to_be::*;

mod to_le;
pub use self::to_le::*;

mod pow;
pub use self::pow::*;

mod parity;
pub use self::parity::*;

mod clear_least_significant_one;
pub use self::clear_least_significant_one::*;

mod set_least_significant_zero;
pub use self::set_least_significant_zero::*;

mod isolate_least_significant_one;
pub use self::isolate_least_significant_one::*;

mod isolate_least_significant_zero;
pub use self::isolate_least_significant_zero::*;

mod clear_trailing_ones;
pub use self::clear_trailing_ones::*;

mod set_trailing_zeros;
pub use self::set_trailing_zeros::*;

mod mask_trailing_zeros;
pub use self::mask_trailing_zeros::*;

mod mask_trailing_ones;
pub use self::mask_trailing_ones::*;

mod mask_trailing_zeros_and_least_significant_one;
pub use self::mask_trailing_zeros_and_least_significant_one::*;

mod mask_trailing_ones_and_least_significant_zero;
pub use self::mask_trailing_ones_and_least_significant_zero::*;

mod set_bit;
pub use self::set_bit::*;

mod clear_bit;
pub use self::clear_bit::*;

mod flip_bit;
pub use self::flip_bit::*;

mod test_bit;
pub use self::test_bit::*;

mod copy_bit;
pub use self::copy_bit::*;

mod reverse_bit_groups;
pub use self::reverse_bit_groups::*;

mod reverse_bits;
pub use self::reverse_bits::*;

mod reverse_bit_pairs;
pub use self::reverse_bit_pairs::*;

mod reverse_bit_nibbles;
pub use self::reverse_bit_nibbles::*;

mod reverse_byte_groups;
pub use self::reverse_byte_groups::*;

mod reverse_bytes;
pub use self::reverse_bytes::*;

mod clear_bits_geq;
pub use self::clear_bits_geq::*;

mod clear_bits_leq;
pub use self::clear_bits_leq::*;

mod set_bits_geq;
pub use self::set_bits_geq::*;

mod set_bits_leq;
pub use self::set_bits_leq::*;

mod flip_bits_geq;
pub use self::flip_bits_geq::*;

mod flip_bits_leq;
pub use self::flip_bits_leq::*;

mod is_pow2;
pub use self::is_pow2::*;

mod ceil_pow2;
pub use self::ceil_pow2::*;

mod floor_pow2;
pub use self::floor_pow2::*;

mod is_aligned;
pub use self::is_aligned::*;

mod align_up;
pub use self::align_up::*;

mod align_down;
pub use self::align_down::*;

mod outer_perfect_shuffle;
pub use self::outer_perfect_shuffle::*;

mod outer_perfect_unshuffle;
pub use self::outer_perfect_unshuffle::*;

mod inner_perfect_shuffle;
pub use self::inner_perfect_shuffle::*;

mod inner_perfect_unshuffle;
pub use self::inner_perfect_unshuffle::*;

mod parallel_bits_deposit;
pub use self::parallel_bits_deposit::*;

mod parallel_bits_extract;
pub use self::parallel_bits_extract::*;

mod extract_bits;
pub use self::extract_bits::*;

mod hamming_distance;
pub use self::hamming_distance::*;

mod is_even;
pub use self::is_even::*;

mod is_odd;
pub use self::is_odd::*;

pub mod gcd;

pub mod morton;
pub use morton::decode_2d as morton_decode_2d;
pub use morton::decode_3d as morton_decode_3d;
pub use morton::encode_2d as morton_encode_2d;
pub use morton::encode_3d as morton_encode_3d;