Debian Codegraph @

.cargo/vendor/rustfft/src/wasm_simd/wasm_simd_utils.rs

raw
1 use core::arch::wasm32::*;
2
3 // __ __ _ _ _________ _ _ _
4 // | \/ | __ _| |_| |__ |___ /___ \| |__ (_) |_
5 // | |\/| |/ _` | __| '_ \ _____ |_ \ __) | '_ \| | __|
6 // | | | | (_| | |_| | | | |_____| ___) / __/| |_) | | |_
7 // |_| |_|\__,_|\__|_| |_| |____/_____|_.__/|_|\__|
8 //
9
10 /// Utility functions to rotate complex numbers by 90 degrees
11 pub struct Rotate90F32 {
12 sign_hi: v128,
13 sign_both: v128,
14 }
15
16 impl Rotate90F32 {
17 pub fn new(positive: bool) -> Self {
18 let sign_hi = if positive {
19 f32x4(0.0, 0.0, -0.0, 0.0)
20 } else {
21 f32x4(0.0, 0.0, 0.0, -0.0)
22 };
23 let sign_both = if positive {
24 f32x4(-0.0, 0.0, -0.0, 0.0)
25 } else {
26 f32x4(0.0, -0.0, 0.0, -0.0)
27 };
28 Self { sign_hi, sign_both }
29 }
30
31 #[inline(always)]
32 pub fn rotate_hi(&self, values: v128) -> v128 {
33 v128_xor(u32x4_shuffle::<0, 1, 3, 2>(values, values), self.sign_hi)
34 }
35
36 #[inline(always)]
37 pub unsafe fn rotate_both(&self, values: v128) -> v128 {
38 v128_xor(u32x4_shuffle::<1, 0, 3, 2>(values, values), self.sign_both)
39 }
40 }
41
42 /// Pack low (1st) complex
43 /// left: l1.re, l1.im, l2.re, l2.im
44 /// right: r1.re, r1.im, r2.re, r2.im
45 /// --> l1.re, l1.im, r1.re, r1.im
46 #[inline(always)]
47 pub fn extract_lo_lo_f32(left: v128, right: v128) -> v128 {
48 u32x4_shuffle::<0, 1, 4, 5>(left, right)
49 }
50
51 /// Pack high (2nd) complex
52 /// left: l1.re, l1.im, l2.re, l2.im
53 /// right: r1.re, r1.im, r2.re, r2.im
54 /// --> l2.re, l2.im, r2.re, r2.im
55 #[inline(always)]
56 pub fn extract_hi_hi_f32(left: v128, right: v128) -> v128 {
57 u32x4_shuffle::<2, 3, 6, 7>(left, right)
58 }
59
60 /// Pack low (1st) and high (2nd) complex
61 /// left: l1.re, l1.im, l2.re, l2.im
62 /// right: r1.re, r1.im, r2.re, r2.im
63 /// --> l1.re, l1.im, r2.re, r2.im
64 #[inline(always)]
65 pub fn extract_lo_hi_f32(left: v128, right: v128) -> v128 {
66 u32x4_shuffle::<0, 1, 6, 7>(left, right)
67 }
68
69 /// Pack high (2nd) and low (1st) complex
70 /// left: r1.re, r1.im, r2.re, r2.im
71 /// right: l1.re, l1.im, l2.re, l2.im
72 /// --> r2.re, r2.im, l1.re, l1.im
73 #[inline(always)]
74 pub fn extract_hi_lo_f32(left: v128, right: v128) -> v128 {
75 u32x4_shuffle::<2, 3, 4, 5>(left, right)
76 }
77
78 /// Reverse complex
79 /// values: a.re, a.im, b.re, b.im
80 /// --> b.re, b.im, a.re, a.im
81 #[inline(always)]
82 pub fn reverse_complex_elements_f32(values: v128) -> v128 {
83 u64x2_shuffle::<1, 0>(values, values)
84 }
85
86 /// Reverse complex and then negate hi complex
87 /// values: a.re, a.im, b.re, b.im
88 /// --> b.re, b.im, -a.re, -a.im
89 #[inline(always)]
90 pub unsafe fn reverse_complex_and_negate_hi_f32(values: v128) -> v128 {
91 v128_xor(
92 u32x4_shuffle::<2, 3, 0, 1>(values, values),
93 f32x4(0.0, 0.0, -0.0, -0.0),
94 )
95 }
96
97 // Invert sign of high (2nd) complex
98 // values: a.re, a.im, b.re, b.im
99 // --> a.re, a.im, -b.re, -b.im
100 //#[inline(always)]
101 //pub unsafe fn negate_hi_f32(values: float32x4_t) -> float32x4_t {
102 // vcombine_f32(vget_low_f32(values), vneg_f32(vget_high_f32(values)))
103 //}
104
105 /// Duplicate low (1st) complex
106 /// values: a.re, a.im, b.re, b.im
107 /// --> a.re, a.im, a.re, a.im
108 #[inline(always)]
109 pub unsafe fn duplicate_lo_f32(values: v128) -> v128 {
110 u64x2_shuffle::<0, 0>(values, values)
111 }
112
113 /// Duplicate high (2nd) complex
114 /// values: a.re, a.im, b.re, b.im
115 /// --> b.re, b.im, b.re, b.im
116 #[inline(always)]
117 pub unsafe fn duplicate_hi_f32(values: v128) -> v128 {
118 u64x2_shuffle::<1, 1>(values, values)
119 }
120
121 /// transpose a 2x2 complex matrix given as [x0, x1], [x2, x3]
122 /// result is [x0, x2], [x1, x3]
123 #[inline(always)]
124 pub unsafe fn transpose_complex_2x2_f32(left: v128, right: v128) -> [v128; 2] {
125 let temp02 = extract_lo_lo_f32(left, right);
126 let temp13 = extract_hi_hi_f32(left, right);
127 [temp02, temp13]
128 }
129
130 /// Complex multiplication.
131 /// Each input contains two complex values, which are multiplied in parallel.
132 #[inline(always)]
133 pub unsafe fn mul_complex_f32(left: v128, right: v128) -> v128 {
134 let temp1 = u32x4_shuffle::<0, 4, 2, 6>(right, right);
135 let temp2 = u32x4_shuffle::<1, 5, 3, 7>(right, f32x4_neg(right));
136 let temp3 = f32x4_mul(temp2, left);
137 let temp4 = u32x4_shuffle::<1, 0, 3, 2>(temp3, temp3);
138 let temp5 = f32x4_mul(temp1, left);
139 f32x4_add(temp4, temp5)
140 }
141
142 // __ __ _ _ __ _ _ _ _ _
143 // | \/ | __ _| |_| |__ / /_ | || | | |__ (_) |_
144 // | |\/| |/ _` | __| '_ \ _____ | '_ \| || |_| '_ \| | __|
145 // | | | | (_| | |_| | | | |_____| | (_) |__ _| |_) | | |_
146 // |_| |_|\__,_|\__|_| |_| \___/ |_| |_.__/|_|\__|
147 //
148
149 /// Utility functions to rotate complex pointers by 90 degrees
150 pub(crate) struct Rotate90F64 {
151 sign: v128,
152 }
153
154 impl Rotate90F64 {
155 pub fn new(positive: bool) -> Self {
156 let sign = if positive {
157 f64x2(-0.0, 0.0)
158 } else {
159 f64x2(0.0, -0.0)
160 };
161 Self { sign }
162 }
163
164 #[inline(always)]
165 pub unsafe fn rotate(&self, values: v128) -> v128 {
166 v128_xor(u64x2_shuffle::<1, 0>(values, values), self.sign)
167 }
168 }
169
170 #[inline(always)]
171 pub unsafe fn mul_complex_f64(left: v128, right: v128) -> v128 {
172 const NEGATE_LEFT: v128 = f64x2(-0.0, 0.0);
173 let temp = v128_xor(u64x2_shuffle::<1, 0>(left, left), NEGATE_LEFT);
174 let sum = f64x2_mul(left, u64x2_shuffle::<0, 0>(right, right));
175 f64x2_add(sum, f64x2_mul(temp, u64x2_shuffle::<1, 1>(right, right)))
176 }
177
178 #[cfg(test)]
179 mod unit_tests {
180 use super::*;
181 use num_complex::Complex;
182 use wasm_bindgen_test::wasm_bindgen_test;
183
184 #[wasm_bindgen_test]
185 fn test_positive_rotation_f32() {
186 unsafe {
187 let rotate = Rotate90F32::new(true);
188 let input = f32x4(1.0, 2.0, 69.0, 420.0);
189 let actual_hi = rotate.rotate_hi(input);
190 let expected_hi = f32x4(1.0, 2.0, -420.0, 69.0);
191 assert_eq!(
192 std::mem::transmute::<v128, [Complex<f32>; 2]>(actual_hi),
193 std::mem::transmute::<v128, [Complex<f32>; 2]>(expected_hi)
194 );
195
196 let actual = rotate.rotate_both(input);
197 let expected = f32x4(-2.0, 1.0, -420.0, 69.0);
198 assert_eq!(
199 std::mem::transmute::<v128, [Complex<f32>; 2]>(actual),
200 std::mem::transmute::<v128, [Complex<f32>; 2]>(expected)
201 );
202 }
203 }
204
205 #[wasm_bindgen_test]
206 fn test_negative_rotation_f32() {
207 unsafe {
208 let rotate = Rotate90F32::new(false);
209 let input = f32x4(1.0, 2.0, 69.0, 420.0);
210 let actual_hi = rotate.rotate_hi(input);
211 let expected_hi = f32x4(1.0, 2.0, 420.0, -69.0);
212 assert_eq!(
213 std::mem::transmute::<v128, [Complex<f32>; 2]>(actual_hi),
214 std::mem::transmute::<v128, [Complex<f32>; 2]>(expected_hi)
215 );
216
217 let actual = rotate.rotate_both(input);
218 let expected = f32x4(2.0, -1.0, 420.0, -69.0);
219 assert_eq!(
220 std::mem::transmute::<v128, [Complex<f32>; 2]>(actual),
221 std::mem::transmute::<v128, [Complex<f32>; 2]>(expected)
222 );
223 }
224 }
225
226 #[wasm_bindgen_test]
227 fn test_negative_rotation_f64() {
228 unsafe {
229 let rotate = Rotate90F64::new(false);
230 let input = f64x2(69.0, 420.0);
231 let actual = rotate.rotate(input);
232 let expected = f64x2(420.0, -69.0);
233 assert_eq!(
234 std::mem::transmute::<v128, Complex<f64>>(actual),
235 std::mem::transmute::<v128, Complex<f64>>(expected)
236 );
237 }
238 }
239
240 #[wasm_bindgen_test]
241 fn test_positive_rotation_f64() {
242 unsafe {
243 let rotate = Rotate90F64::new(true);
244 let input = f64x2(69.0, 420.0);
245 let actual = rotate.rotate(input);
246 let expected = f64x2(-420.0, 69.0);
247 assert_eq!(
248 std::mem::transmute::<v128, Complex<f64>>(actual),
249 std::mem::transmute::<v128, Complex<f64>>(expected)
250 );
251 }
252 }
253
254 #[wasm_bindgen_test]
255 fn test_reverse_complex_number_f32() {
256 let input = f32x4(1.0, 5.0, 9.0, 13.0);
257 let actual = reverse_complex_elements_f32(input);
258 let expected = f32x4(9.0, 13.0, 1.0, 5.0);
259 unsafe {
260 assert_eq!(
261 std::mem::transmute::<v128, [Complex<f32>; 2]>(actual),
262 std::mem::transmute::<v128, [Complex<f32>; 2]>(expected)
263 );
264 }
265 }
266
267 #[wasm_bindgen_test]
268 fn test_mul_complex_f64() {
269 unsafe {
270 // let right = vld1q_f64([1.0, 2.0].as_ptr());
271 let right = f64x2(1.0, 2.0);
272 // let left = vld1q_f64([5.0, 7.0].as_ptr());
273 let left = f64x2(5.0, 7.0);
274 let res = mul_complex_f64(left, right);
275 // let expected = vld1q_f64([1.0 * 5.0 - 2.0 * 7.0, 1.0 * 7.0 + 2.0 * 5.0].as_ptr());
276 let expected = f64x2(1.0 * 5.0 - 2.0 * 7.0, 1.0 * 7.0 + 2.0 * 5.0);
277 assert_eq!(
278 std::mem::transmute::<v128, Complex<f64>>(res),
279 std::mem::transmute::<v128, Complex<f64>>(expected)
280 );
281 }
282 }
283
284 #[wasm_bindgen_test]
285 fn test_mul_complex_f32() {
286 unsafe {
287 let val1 = Complex::<f32>::new(1.0, 2.5);
288 let val2 = Complex::<f32>::new(3.2, 4.75);
289 let val3 = Complex::<f32>::new(5.75, 6.25);
290 let val4 = Complex::<f32>::new(7.4, 8.5);
291
292 let nbr2 = v128_load([val3, val4].as_ptr() as *const v128);
293 let nbr1 = v128_load([val1, val2].as_ptr() as *const v128);
294 let res = mul_complex_f32(nbr1, nbr2);
295 let res = std::mem::transmute::<v128, [Complex<f32>; 2]>(res);
296 let expected = [val1 * val3, val2 * val4];
297 assert_eq!(res, expected);
298 }
299 }
300
301 #[wasm_bindgen_test]
302 fn test_pack() {
303 unsafe {
304 let nbr2 = f32x4(5.0, 6.0, 7.0, 8.0);
305 let nbr1 = f32x4(1.0, 2.0, 3.0, 4.0);
306 let first = extract_lo_lo_f32(nbr1, nbr2);
307 let second = extract_hi_hi_f32(nbr1, nbr2);
308 let first = std::mem::transmute::<v128, [Complex<f32>; 2]>(first);
309 let second = std::mem::transmute::<v128, [Complex<f32>; 2]>(second);
310 let first_expected = [Complex::new(1.0, 2.0), Complex::new(5.0, 6.0)];
311 let second_expected = [Complex::new(3.0, 4.0), Complex::new(7.0, 8.0)];
312 assert_eq!(first, first_expected);
313 assert_eq!(second, second_expected);
314 }
315 }
316 }