Debian Codegraph @

.cargo/vendor/rustfft/benches/compare_3n2m_strategies.rs

raw
1 #![feature(test)]
2 #![allow(non_snake_case)]
3 #![allow(unused)]
4
5 extern crate rustfft;
6 extern crate test;
7 use test::Bencher;
8
9 use rustfft::algorithm::butterflies::*;
10 use rustfft::algorithm::Dft;
11 use rustfft::num_complex::Complex;
12 use rustfft::num_traits::Zero;
13 use rustfft::{Fft, FftNum};
14 use rustfft::{FftPlanner, FftPlannerAvx};
15
16 use primal_check::miller_rabin;
17
18 use std::sync::Arc;
19
20 /// This benchmark's purpose is to build some programmer intuition for planner heuristics
21 /// We have mixed radix 2xn, 3xn, 4xn, 6xn, 8xn, 9x, 12xn, and 16xn implementations -- for a given FFT of the form 2^xn * 3^m, which combination is the fastest? Is 12xn -> 4xn faster than 6xn -> 8xn?
22 /// Is it faster to put 9xn as an outer FFT of 8xn or as an inner FFT? this file autogenerates benchmarks that answer these questions
23 ///
24 /// The "generate_3n2m_comparison_benchmarks" benchmark will print benchmark code to the console which should be pasted back into this file, basically a low-budget procedural macro
25
26 #[derive(Clone, Debug)]
27 struct FftSize {
28 len: usize,
29 power2: u32,
30 power3: u32,
31 }
32 impl FftSize {
33 fn new(len: usize) -> Self {
34 let power2 = len.trailing_zeros();
35 let mut remaining_factors = len >> power2;
36 let mut power3 = 0;
37 while remaining_factors % 3 == 0 {
38 power3 += 1;
39 remaining_factors /= 3;
40 }
41
42 assert!(remaining_factors == 1);
43 Self {
44 power2,
45 power3,
46 len,
47 }
48 }
49
50 fn divide(&self, other: &Self) -> Option<Self> {
51 if self.power2 <= other.power2 && self.power3 <= other.power3 {
52 Some(Self {
53 power2: other.power2 - self.power2,
54 power3: other.power3 - self.power3,
55 len: other.len / self.len,
56 })
57 } else {
58 None
59 }
60 }
61 }
62
63 // We don't need to generate a combinatoric explosion of tests that we know will be slow. filter_radix applies some dumb heuristics to filter out the most common slow cases
64 fn filter_radix(current_strategy: &[usize], potential_radix: &FftSize, is_butterfly: bool) -> bool {
65 // if we've seen any radix larger than this before, reject. otherwise we'll get a million reorderings of the same radixex, with benchmarking showing that smaller being higher is typically faster
66 if !is_butterfly
67 && current_strategy
68 .iter()
69 .find(|i| **i > potential_radix.len && **i != 16)
70 .is_some()
71 {
72 return false;
73 }
74
75 // apply filters to size 2
76 if potential_radix.len == 2 {
77 // if our strategy already contains any 2's, 3's, or 4's, reject -- because 4, 6, or 8 will be faster, respectively
78 return !current_strategy.contains(&2)
79 && !current_strategy.contains(&3)
80 && !current_strategy.contains(&4);
81 }
82 // apply filters to size 3
83 if potential_radix.len == 3 {
84 // if our strategy already contains any 2's, 3's or 4s, reject -- because 6 and 9 and 12 will be faster, respectively
85 return !current_strategy.contains(&2)
86 && !current_strategy.contains(&3)
87 && !current_strategy.contains(&4);
88 }
89 // apply filters to size 4
90 if potential_radix.len == 4 {
91 // if our strategy already contains any 2's, reject -- because 8 will be faster
92 // if our strategy already contains 2 4's, don't add a third, because 2 8's would have been faster
93 // if our strategy already contains a 16, reject -- because 2 8's will be faster (8s are seriously fast guys)
94 return !current_strategy.contains(&2)
95 && !current_strategy.contains(&3)
96 && !current_strategy.contains(&4)
97 && !current_strategy.contains(&16);
98 }
99 if potential_radix.len == 16 {
100 // if our strategy already contains a 4, reject -- because 2 8's will be faster (8s are seriously fast guys)
101 // if our strategy already contains a 16, reject -- benchmarking shows that 16s are very situational, and repeating them never helps)
102 return !current_strategy.contains(&4) && !current_strategy.contains(&16);
103 }
104 return true;
105 }
106
107 fn recursive_strategy_builder(
108 strategy_list: &mut Vec<Vec<usize>>,
109 last_ditch_strategy_list: &mut Vec<Vec<usize>>,
110 mut current_strategy: Vec<usize>,
111 len: FftSize,
112 butterfly_sizes: &[usize],
113 last_ditch_butterflies: &[usize],
114 available_radixes: &[FftSize],
115 ) {
116 if butterfly_sizes.contains(&len.len) {
117 if filter_radix(&current_strategy, &len, true) {
118 current_strategy.push(len.len);
119
120 //If this strategy contains a 2 or 3, it's very unlikely to be the fastest. we don't want to rule it out, because it's required sometimes, but don't use it unless there aren't any other
121 if current_strategy.contains(&2) || current_strategy.contains(&3) {
122 strategy_list.push(current_strategy.clone());
123 } else {
124 strategy_list.push(current_strategy.clone());
125 }
126 }
127 } else if last_ditch_butterflies.contains(&len.len) {
128 if filter_radix(&current_strategy, &len, true) {
129 current_strategy.push(len.len);
130 last_ditch_strategy_list.push(current_strategy.clone());
131 }
132 } else if len.len > 1 {
133 for radix in available_radixes {
134 if filter_radix(&current_strategy, radix, false) {
135 if let Some(inner) = radix.divide(&len) {
136 let mut cloned_strategy = current_strategy.clone();
137 cloned_strategy.push(radix.len);
138 recursive_strategy_builder(
139 strategy_list,
140 last_ditch_strategy_list,
141 cloned_strategy,
142 inner,
143 butterfly_sizes,
144 last_ditch_butterflies,
145 available_radixes,
146 );
147 }
148 }
149 }
150 }
151 }
152
153 // it's faster to filter strategies at the radix level since we can prune entire permutations, but some can only be done once the full plan is built
154 fn filter_strategy(strategy: &Vec<usize>) -> bool {
155 if strategy.contains(&16) {
156 let index = strategy.iter().position(|s| *s == 16).unwrap();
157 index == 0
158 || index == strategy.len() - 1
159 || index == strategy.len() - 2
160 || (strategy[index - 1] < 12 && strategy[index + 1] >= 12)
161 } else {
162 true
163 }
164 }
165
166 // cargo bench generate_3n2m_comparison_benchmarks_32 -- --nocapture --ignored
167 #[ignore]
168 #[bench]
169 fn generate_3n2m_comparison_benchmarks_32(_: &mut test::Bencher) {
170 let butterfly_sizes = [128, 256, 512, 72, 36, 48, 54, 64];
171 let last_ditch_butterflies = [27, 9, 32, 24];
172 let available_radixes = [
173 FftSize::new(3),
174 FftSize::new(4),
175 FftSize::new(6),
176 FftSize::new(8),
177 FftSize::new(9),
178 FftSize::new(12),
179 FftSize::new(16),
180 ];
181
182 let max_len: usize = 1 << 21;
183 let min_len = 64;
184 let max_power2 = max_len.trailing_zeros();
185 let max_power3 = (max_len as f32).log(3.0).ceil() as u32;
186
187 for power3 in 1..2 {
188 for power2 in 4..max_power2 {
189 let len = 3usize.pow(power3) << power2;
190 if len > max_len {
191 continue;
192 }
193
194 //let planned_fft : Arc<dyn Fft<f32>> = rustfft::FftPlanner::new(false).plan_fft(len);
195
196 // we want to catalog all the different possible ways there are to compute a FFT of size `len`
197 // we can do that by recursively looping over each radix, dividing our length by that radix, then recursively trying rach radix again
198 let mut strategies = vec![];
199 let mut last_ditch_strategies = vec![];
200 recursive_strategy_builder(
201 &mut strategies,
202 &mut last_ditch_strategies,
203 Vec::new(),
204 FftSize::new(len),
205 &butterfly_sizes,
206 &last_ditch_butterflies,
207 &available_radixes,
208 );
209
210 if strategies.len() == 0 {
211 strategies = last_ditch_strategies;
212 }
213
214 for mut s in strategies.into_iter().filter(filter_strategy) {
215 s.reverse();
216 let strategy_strings: Vec<_> = s.into_iter().map(|i| i.to_string()).collect();
217 let test_id = strategy_strings.join("_");
218 let strategy_array = strategy_strings.join(",");
219 println!("#[bench] fn comparef32__2power{:02}__3power{:02}__len{:08}__{}(b: &mut Bencher) {{ compare_fft_f32(b, &[{}]); }}", power2, power3, len, test_id, strategy_array);
220 }
221 }
222 }
223 }
224
225 // cargo bench generate_3n2m_comparison_benchmarks_64 -- --nocapture --ignored
226 #[ignore]
227 #[bench]
228 fn generate_3n2m_comparison_benchmarks_64(_: &mut test::Bencher) {
229 let butterfly_sizes = [512, 256, 128, 64, 36, 27, 24, 18, 12];
230 let last_ditch_butterflies = [32, 16, 8, 9];
231 let available_radixes = [
232 FftSize::new(3),
233 FftSize::new(4),
234 FftSize::new(6),
235 FftSize::new(8),
236 FftSize::new(9),
237 FftSize::new(12),
238 ];
239
240 let max_len: usize = 1 << 21;
241 let min_len = 64;
242 let max_power2 = max_len.trailing_zeros();
243 let max_power3 = (max_len as f32).log(3.0).ceil() as u32;
244
245 for power3 in 0..1 {
246 for power2 in 3..max_power2 {
247 let len = 3usize.pow(power3) << power2;
248 if len > max_len {
249 continue;
250 }
251
252 //let planned_fft : Arc<dyn Fft<f32>> = rustfft::FftPlanner::new(false).plan_fft(len);
253
254 // we want to catalog all the different possible ways there are to compute a FFT of size `len`
255 // we can do that by recursively looping over each radix, dividing our length by that radix, then recursively trying rach radix again
256 // we can do that by recursively looping over each radix, dividing our length by that radix, then recursively trying rach radix again
257 let mut strategies = vec![];
258 let mut last_ditch_strategies = vec![];
259 recursive_strategy_builder(
260 &mut strategies,
261 &mut last_ditch_strategies,
262 Vec::new(),
263 FftSize::new(len),
264 &butterfly_sizes,
265 &last_ditch_butterflies,
266 &available_radixes,
267 );
268
269 if strategies.len() == 0 {
270 strategies = last_ditch_strategies;
271 }
272
273 for mut s in strategies.into_iter().filter(filter_strategy) {
274 s.reverse();
275 let strategy_strings: Vec<_> = s.into_iter().map(|i| i.to_string()).collect();
276 let test_id = strategy_strings.join("_");
277 let strategy_array = strategy_strings.join(",");
278 println!("#[bench] fn comparef64__2power{:02}__3power{:02}__len{:08}__{}(b: &mut Bencher) {{ compare_fft_f64(b, &[{}]); }}", power2, power3, len, test_id, strategy_array);
279 }
280 }
281 }
282 }
283
284 // cargo bench generate_3n2m_planned_benchmarks_32 -- --nocapture --ignored
285 #[ignore]
286 #[bench]
287 fn generate_3n2m_planned_benchmarks(_: &mut test::Bencher) {
288 let mut fft_sizes = vec![];
289
290 let max_len: usize = 1 << 23;
291 let max_power2 = max_len.trailing_zeros();
292 let max_power3 = (max_len as f32).log(3.0).ceil() as u32;
293 for power2 in 0..max_power2 {
294 for power3 in 0..max_power3 {
295 let len = 3usize.pow(power3) << power2;
296 if len > max_len {
297 continue;
298 }
299 if power3 < 2 && power2 > 16 {
300 continue;
301 }
302 if power3 < 3 && power2 > 17 {
303 continue;
304 }
305 if power2 < 1 {
306 continue;
307 }
308 fft_sizes.push(len);
309 }
310 }
311
312 for len in fft_sizes {
313 let power2 = len.trailing_zeros();
314 let mut remaining_factors = len >> power2;
315 let mut power3 = 0;
316 while remaining_factors % 3 == 0 {
317 power3 += 1;
318 remaining_factors /= 3;
319 }
320
321 println!("#[bench] fn comparef32_len{:07}_2power{:02}_3power{:02}(b: &mut Bencher) {{ bench_planned_fft_f32(b, {}); }}",len, power2, power3, len);
322 }
323 }
324
325 // cargo bench generate_3n2m_planned_benchmarks_64 -- --nocapture --ignored
326 #[ignore]
327 #[bench]
328 fn generate_3n2m_planned_benchmarks_64(_: &mut test::Bencher) {
329 let mut fft_sizes = vec![];
330
331 let max_len: usize = 1 << 23;
332 let max_power2 = max_len.trailing_zeros();
333 let max_power3 = (max_len as f32).log(3.0).ceil() as u32;
334 for power2 in 0..max_power2 {
335 for power3 in 0..max_power3 {
336 let len = 3usize.pow(power3) << power2;
337 if len > max_len {
338 continue;
339 }
340 if power3 < 1 && power2 > 13 {
341 continue;
342 }
343 if power3 < 4 && power2 > 14 {
344 continue;
345 }
346 if power2 < 2 {
347 continue;
348 }
349 fft_sizes.push(len);
350 }
351 }
352
353 for len in fft_sizes {
354 let power2 = len.trailing_zeros();
355 let mut remaining_factors = len >> power2;
356 let mut power3 = 0;
357 while remaining_factors % 3 == 0 {
358 power3 += 1;
359 remaining_factors /= 3;
360 }
361
362 println!("#[bench] fn comparef64_len{:07}_2power{:02}_3power{:02}(b: &mut Bencher) {{ bench_planned_fft_f64(b, {}); }}",len, power2, power3, len);
363 }
364 }
365
366 #[derive(Copy, Clone, Debug)]
367 pub struct PartialFactors {
368 power2: u32,
369 power3: u32,
370 power5: u32,
371 power7: u32,
372 power11: u32,
373 other_factors: usize,
374 }
375 impl PartialFactors {
376 pub fn compute(len: usize) -> Self {
377 let power2 = len.trailing_zeros();
378 let mut other_factors = len >> power2;
379
380 let mut power3 = 0;
381 while other_factors % 3 == 0 {
382 power3 += 1;
383 other_factors /= 3;
384 }
385
386 let mut power5 = 0;
387 while other_factors % 5 == 0 {
388 power5 += 1;
389 other_factors /= 5;
390 }
391
392 let mut power7 = 0;
393 while other_factors % 7 == 0 {
394 power7 += 1;
395 other_factors /= 7;
396 }
397
398 let mut power11 = 0;
399 while other_factors % 11 == 0 {
400 power11 += 1;
401 other_factors /= 11;
402 }
403
404 Self {
405 power2,
406 power3,
407 power5,
408 power7,
409 power11,
410 other_factors,
411 }
412 }
413
414 pub fn get_power2(&self) -> u32 {
415 self.power2
416 }
417 pub fn get_power3(&self) -> u32 {
418 self.power3
419 }
420 pub fn get_power5(&self) -> u32 {
421 self.power5
422 }
423 pub fn get_power7(&self) -> u32 {
424 self.power7
425 }
426 pub fn get_power11(&self) -> u32 {
427 self.power11
428 }
429 pub fn get_other_factors(&self) -> usize {
430 self.other_factors
431 }
432 pub fn product(&self) -> usize {
433 (self.other_factors
434 * 3usize.pow(self.power3)
435 * 5usize.pow(self.power5)
436 * 7usize.pow(self.power7)
437 * 11usize.pow(self.power11))
438 << self.power2
439 }
440 pub fn product_power2power3(&self) -> usize {
441 3usize.pow(self.power3) << self.power2
442 }
443 #[allow(unused)]
444 pub fn divide_by(&self, divisor: &PartialFactors) -> Option<PartialFactors> {
445 let two_divides = self.power2 >= divisor.power2;
446 let three_divides = self.power3 >= divisor.power3;
447 let five_divides = self.power5 >= divisor.power5;
448 let seven_divides = self.power7 >= divisor.power7;
449 let eleven_divides = self.power11 >= divisor.power11;
450 let other_divides = self.other_factors % divisor.other_factors == 0;
451 if two_divides
452 && three_divides
453 && five_divides
454 && seven_divides
455 && eleven_divides
456 && other_divides
457 {
458 Some(Self {
459 power2: self.power2 - divisor.power2,
460 power3: self.power3 - divisor.power3,
461 power5: self.power5 - divisor.power5,
462 power7: self.power7 - divisor.power7,
463 power11: self.power11 - divisor.power11,
464 other_factors: if self.other_factors == divisor.other_factors {
465 1
466 } else {
467 self.other_factors / divisor.other_factors
468 },
469 })
470 } else {
471 None
472 }
473 }
474 }
475
476 // cargo bench generate_raders_benchmarks -- --nocapture --ignored
477 #[ignore]
478 #[bench]
479 fn generate_raders_benchmarks(_: &mut test::Bencher) {
480 for len in 10usize..100000 {
481 if miller_rabin(len as u64) {
482 let inner_factors = PartialFactors::compute(len - 1);
483 if inner_factors.get_other_factors() == 1 && inner_factors.get_power11() > 0 {
484 println!("#[bench] fn comparef64_len{:07}_11p{:02}_bluesteins(b: &mut Bencher) {{ bench_planned_bluesteins_f64(b, {}); }}", len, inner_factors.get_power11(), len);
485 println!("#[bench] fn comparef64_len{:07}_11p{:02}_raders(b: &mut Bencher) {{ bench_planned_raders_f64(b, {}); }}", len, inner_factors.get_power11(), len);
486 }
487 }
488 }
489 }
490
491 fn wrap_fft<T: FftNum>(fft: impl Fft<T> + 'static) -> Arc<dyn Fft<T>> {
492 Arc::new(fft) as Arc<dyn Fft<T>>
493 }
494
495 // passes the given FFT length directly to the FFT planner
496 fn bench_planned_fft_f32(b: &mut Bencher, len: usize) {
497 let mut planner: FftPlanner<f32> = FftPlanner::new();
498 let fft = planner.plan_fft_forward(len);
499
500 let mut buffer = vec![Complex::zero(); fft.len()];
501 let mut scratch = vec![Complex::zero(); fft.get_inplace_scratch_len()];
502 b.iter(|| {
503 fft.process_with_scratch(&mut buffer, &mut scratch);
504 });
505 }
506
507 // passes the given FFT length directly to the FFT planner
508 fn bench_planned_fft_f64(b: &mut Bencher, len: usize) {
509 let mut planner: FftPlanner<f64> = FftPlanner::new();
510 let fft = planner.plan_fft_forward(len);
511
512 let mut buffer = vec![Complex::zero(); fft.len()];
513 let mut scratch = vec![Complex::zero(); fft.get_inplace_scratch_len()];
514 b.iter(|| {
515 fft.process_with_scratch(&mut buffer, &mut scratch);
516 });
517 }
518
519 /*
520
521 // Computes the given FFT length using Bluestein's Algorithm, using the planner to plan the inner FFT
522 fn bench_planned_bluesteins_f32(b: &mut Bencher, len: usize) {
523 let mut planner : FftPlannerAvx<f32> = FftPlannerAvx::new(false).unwrap();
524 let fft = planner.construct_bluesteins(len);
525
526 let mut buffer = vec![Complex::zero(); fft.len()];
527 let mut scratch = vec![Complex::zero(); fft.get_inplace_scratch_len()];
528 b.iter(|| { fft.process_with_scratch(&mut buffer, &mut scratch); });
529 }
530
531 // Computes the given FFT length using Rader's Algorithm, using the planner to plan the inner FFT
532 fn bench_planned_raders_f32(b: &mut Bencher, len: usize) {
533 let mut planner : FftPlannerAvx<f32> = FftPlannerAvx::new(false).unwrap();
534 let fft = planner.construct_raders(len);
535
536 let mut buffer = vec![Complex::zero(); fft.len()];
537 let mut scratch = vec![Complex::zero(); fft.get_inplace_scratch_len()];
538 b.iter(|| { fft.process_with_scratch(&mut buffer, &mut scratch); });
539 }
540
541 // Computes the given FFT length using Bluestein's Algorithm, using the planner to plan the inner FFT
542 fn bench_planned_bluesteins_f64(b: &mut Bencher, len: usize) {
543 let mut planner : FftPlannerAvx<f64> = FftPlannerAvx::new(false).unwrap();
544 let fft = planner.construct_bluesteins(len);
545
546 let mut buffer = vec![Complex::zero(); fft.len()];
547 let mut scratch = vec![Complex::zero(); fft.get_inplace_scratch_len()];
548 b.iter(|| { fft.process_with_scratch(&mut buffer, &mut scratch); });
549 }
550
551 // Computes the given FFT length using Rader's Algorithm, using the planner to plan the inner FFT
552 fn bench_planned_raders_f64(b: &mut Bencher, len: usize) {
553 let mut planner : FftPlannerAvx<f64> = FftPlannerAvx::new(false).unwrap();
554 let fft = planner.construct_raders(len);
555
556 let mut buffer = vec![Complex::zero(); fft.len()];
557 let mut scratch = vec![Complex::zero(); fft.get_inplace_scratch_len()];
558 b.iter(|| { fft.process_with_scratch(&mut buffer, &mut scratch); });
559 }
560
561 #[bench] fn comparef64_len0000023_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 23); }
562 #[bench] fn comparef64_len0000023_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 23); }
563 #[bench] fn comparef64_len0000067_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 67); }
564 #[bench] fn comparef64_len0000067_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 67); }
565 #[bench] fn comparef64_len0000089_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 89); }
566 #[bench] fn comparef64_len0000089_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 89); }
567 #[bench] fn comparef64_len0000199_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 199); }
568 #[bench] fn comparef64_len0000199_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 199); }
569 #[bench] fn comparef64_len0000331_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 331); }
570 #[bench] fn comparef64_len0000331_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 331); }
571 #[bench] fn comparef64_len0000353_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 353); }
572 #[bench] fn comparef64_len0000353_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 353); }
573 #[bench] fn comparef64_len0000397_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 397); }
574 #[bench] fn comparef64_len0000397_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 397); }
575 #[bench] fn comparef64_len0000463_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 463); }
576 #[bench] fn comparef64_len0000463_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 463); }
577 #[bench] fn comparef64_len0000617_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 617); }
578 #[bench] fn comparef64_len0000617_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 617); }
579 #[bench] fn comparef64_len0000661_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 661); }
580 #[bench] fn comparef64_len0000661_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 661); }
581 #[bench] fn comparef64_len0000727_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 727); }
582 #[bench] fn comparef64_len0000727_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 727); }
583 #[bench] fn comparef64_len0000881_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 881); }
584 #[bench] fn comparef64_len0000881_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 881); }
585 #[bench] fn comparef64_len0000991_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 991); }
586 #[bench] fn comparef64_len0000991_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 991); }
587 #[bench] fn comparef64_len0001321_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 1321); }
588 #[bench] fn comparef64_len0001321_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 1321); }
589 #[bench] fn comparef64_len0001409_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 1409); }
590 #[bench] fn comparef64_len0001409_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 1409); }
591 #[bench] fn comparef64_len0001453_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 1453); }
592 #[bench] fn comparef64_len0001453_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 1453); }
593 #[bench] fn comparef64_len0001783_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 1783); }
594 #[bench] fn comparef64_len0001783_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 1783); }
595 #[bench] fn comparef64_len0002113_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 2113); }
596 #[bench] fn comparef64_len0002113_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 2113); }
597 #[bench] fn comparef64_len0002179_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 2179); }
598 #[bench] fn comparef64_len0002179_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 2179); }
599 #[bench] fn comparef64_len0002311_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 2311); }
600 #[bench] fn comparef64_len0002311_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 2311); }
601 #[bench] fn comparef64_len0002377_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 2377); }
602 #[bench] fn comparef64_len0002377_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 2377); }
603 #[bench] fn comparef64_len0002663_11p03_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 2663); }
604 #[bench] fn comparef64_len0002663_11p03_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 2663); }
605 #[bench] fn comparef64_len0002971_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 2971); }
606 #[bench] fn comparef64_len0002971_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 2971); }
607 #[bench] fn comparef64_len0003169_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 3169); }
608 #[bench] fn comparef64_len0003169_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 3169); }
609 #[bench] fn comparef64_len0003301_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 3301); }
610 #[bench] fn comparef64_len0003301_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 3301); }
611 #[bench] fn comparef64_len0003389_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 3389); }
612 #[bench] fn comparef64_len0003389_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 3389); }
613 #[bench] fn comparef64_len0003631_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 3631); }
614 #[bench] fn comparef64_len0003631_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 3631); }
615 #[bench] fn comparef64_len0003697_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 3697); }
616 #[bench] fn comparef64_len0003697_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 3697); }
617 #[bench] fn comparef64_len0003851_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 3851); }
618 #[bench] fn comparef64_len0003851_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 3851); }
619 #[bench] fn comparef64_len0004159_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 4159); }
620 #[bench] fn comparef64_len0004159_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 4159); }
621 #[bench] fn comparef64_len0004357_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 4357); }
622 #[bench] fn comparef64_len0004357_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 4357); }
623 #[bench] fn comparef64_len0004621_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 4621); }
624 #[bench] fn comparef64_len0004621_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 4621); }
625 #[bench] fn comparef64_len0004951_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 4951); }
626 #[bench] fn comparef64_len0004951_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 4951); }
627 #[bench] fn comparef64_len0005281_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 5281); }
628 #[bench] fn comparef64_len0005281_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 5281); }
629 #[bench] fn comparef64_len0005347_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 5347); }
630 #[bench] fn comparef64_len0005347_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 5347); }
631 #[bench] fn comparef64_len0005501_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 5501); }
632 #[bench] fn comparef64_len0005501_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 5501); }
633 #[bench] fn comparef64_len0006337_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 6337); }
634 #[bench] fn comparef64_len0006337_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 6337); }
635 #[bench] fn comparef64_len0006469_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 6469); }
636 #[bench] fn comparef64_len0006469_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 6469); }
637 #[bench] fn comparef64_len0007129_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 7129); }
638 #[bench] fn comparef64_len0007129_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 7129); }
639 #[bench] fn comparef64_len0007393_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 7393); }
640 #[bench] fn comparef64_len0007393_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 7393); }
641 #[bench] fn comparef64_len0007547_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 7547); }
642 #[bench] fn comparef64_len0007547_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 7547); }
643 #[bench] fn comparef64_len0008317_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 8317); }
644 #[bench] fn comparef64_len0008317_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 8317); }
645 #[bench] fn comparef64_len0008713_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 8713); }
646 #[bench] fn comparef64_len0008713_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 8713); }
647 #[bench] fn comparef64_len0009241_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 9241); }
648 #[bench] fn comparef64_len0009241_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 9241); }
649 #[bench] fn comparef64_len0009857_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 9857); }
650 #[bench] fn comparef64_len0009857_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 9857); }
651 #[bench] fn comparef64_len0009901_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 9901); }
652 #[bench] fn comparef64_len0009901_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 9901); }
653 #[bench] fn comparef64_len0010781_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 10781); }
654 #[bench] fn comparef64_len0010781_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 10781); }
655 #[bench] fn comparef64_len0010891_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 10891); }
656 #[bench] fn comparef64_len0010891_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 10891); }
657 #[bench] fn comparef64_len0011551_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 11551); }
658 #[bench] fn comparef64_len0011551_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 11551); }
659 #[bench] fn comparef64_len0011617_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 11617); }
660 #[bench] fn comparef64_len0011617_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 11617); }
661 #[bench] fn comparef64_len0012101_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 12101); }
662 #[bench] fn comparef64_len0012101_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 12101); }
663 #[bench] fn comparef64_len0013553_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 13553); }
664 #[bench] fn comparef64_len0013553_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 13553); }
665 #[bench] fn comparef64_len0013751_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 13751); }
666 #[bench] fn comparef64_len0013751_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 13751); }
667 #[bench] fn comparef64_len0014081_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 14081); }
668 #[bench] fn comparef64_len0014081_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 14081); }
669 #[bench] fn comparef64_len0014851_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 14851); }
670 #[bench] fn comparef64_len0014851_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 14851); }
671 #[bench] fn comparef64_len0015401_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 15401); }
672 #[bench] fn comparef64_len0015401_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 15401); }
673 #[bench] fn comparef64_len0015973_11p03_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 15973); }
674 #[bench] fn comparef64_len0015973_11p03_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 15973); }
675 #[bench] fn comparef64_len0016633_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 16633); }
676 #[bench] fn comparef64_len0016633_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 16633); }
677 #[bench] fn comparef64_len0018481_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 18481); }
678 #[bench] fn comparef64_len0018481_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 18481); }
679 #[bench] fn comparef64_len0019009_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 19009); }
680 #[bench] fn comparef64_len0019009_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 19009); }
681 #[bench] fn comparef64_len0019603_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 19603); }
682 #[bench] fn comparef64_len0019603_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 19603); }
683 #[bench] fn comparef64_len0019801_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 19801); }
684 #[bench] fn comparef64_len0019801_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 19801); }
685 #[bench] fn comparef64_len0021121_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 21121); }
686 #[bench] fn comparef64_len0021121_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 21121); }
687 #[bench] fn comparef64_len0022639_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 22639); }
688 #[bench] fn comparef64_len0022639_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 22639); }
689 #[bench] fn comparef64_len0023761_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 23761); }
690 #[bench] fn comparef64_len0023761_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 23761); }
691 #[bench] fn comparef64_len0025411_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 25411); }
692 #[bench] fn comparef64_len0025411_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 25411); }
693 #[bench] fn comparef64_len0025873_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 25873); }
694 #[bench] fn comparef64_len0025873_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 25873); }
695 #[bench] fn comparef64_len0026731_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 26731); }
696 #[bench] fn comparef64_len0026731_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 26731); }
697 #[bench] fn comparef64_len0026951_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 26951); }
698 #[bench] fn comparef64_len0026951_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 26951); }
699 #[bench] fn comparef64_len0028513_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 28513); }
700 #[bench] fn comparef64_len0028513_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 28513); }
701 #[bench] fn comparef64_len0029569_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 29569); }
702 #[bench] fn comparef64_len0029569_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 29569); }
703 #[bench] fn comparef64_len0030493_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 30493); }
704 #[bench] fn comparef64_len0030493_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 30493); }
705 #[bench] fn comparef64_len0030977_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 30977); }
706 #[bench] fn comparef64_len0030977_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 30977); }
707 #[bench] fn comparef64_len0032077_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 32077); }
708 #[bench] fn comparef64_len0032077_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 32077); }
709 #[bench] fn comparef64_len0032341_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 32341); }
710 #[bench] fn comparef64_len0032341_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 32341); }
711 #[bench] fn comparef64_len0034651_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 34651); }
712 #[bench] fn comparef64_len0034651_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 34651); }
713 #[bench] fn comparef64_len0034849_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 34849); }
714 #[bench] fn comparef64_len0034849_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 34849); }
715 #[bench] fn comparef64_len0035201_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 35201); }
716 #[bench] fn comparef64_len0035201_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 35201); }
717 #[bench] fn comparef64_len0037423_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 37423); }
718 #[bench] fn comparef64_len0037423_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 37423); }
719 #[bench] fn comparef64_len0038501_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 38501); }
720 #[bench] fn comparef64_len0038501_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 38501); }
721 #[bench] fn comparef64_len0047521_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 47521); }
722 #[bench] fn comparef64_len0047521_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 47521); }
723 #[bench] fn comparef64_len0047917_11p03_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 47917); }
724 #[bench] fn comparef64_len0047917_11p03_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 47917); }
725 #[bench] fn comparef64_len0050821_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 50821); }
726 #[bench] fn comparef64_len0050821_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 50821); }
727 #[bench] fn comparef64_len0055001_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 55001); }
728 #[bench] fn comparef64_len0055001_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 55001); }
729 #[bench] fn comparef64_len0055441_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 55441); }
730 #[bench] fn comparef64_len0055441_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 55441); }
731 #[bench] fn comparef64_len0055903_11p03_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 55903); }
732 #[bench] fn comparef64_len0055903_11p03_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 55903); }
733 #[bench] fn comparef64_len0057751_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 57751); }
734 #[bench] fn comparef64_len0057751_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 57751); }
735 #[bench] fn comparef64_len0063361_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 63361); }
736 #[bench] fn comparef64_len0063361_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 63361); }
737 #[bench] fn comparef64_len0064153_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 64153); }
738 #[bench] fn comparef64_len0064153_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 64153); }
739 #[bench] fn comparef64_len0066529_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 66529); }
740 #[bench] fn comparef64_len0066529_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 66529); }
741 #[bench] fn comparef64_len0068993_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 68993); }
742 #[bench] fn comparef64_len0068993_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 68993); }
743 #[bench] fn comparef64_len0069697_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 69697); }
744 #[bench] fn comparef64_len0069697_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 69697); }
745 #[bench] fn comparef64_len0076231_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 76231); }
746 #[bench] fn comparef64_len0076231_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 76231); }
747 #[bench] fn comparef64_len0077617_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 77617); }
748 #[bench] fn comparef64_len0077617_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 77617); }
749 #[bench] fn comparef64_len0079201_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 79201); }
750 #[bench] fn comparef64_len0079201_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 79201); }
751 #[bench] fn comparef64_len0079861_11p03_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 79861); }
752 #[bench] fn comparef64_len0079861_11p03_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 79861); }
753 #[bench] fn comparef64_len0080191_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 80191); }
754 #[bench] fn comparef64_len0080191_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 80191); }
755 #[bench] fn comparef64_len0084481_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 84481); }
756 #[bench] fn comparef64_len0084481_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 84481); }
757 #[bench] fn comparef64_len0084701_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 84701); }
758 #[bench] fn comparef64_len0084701_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 84701); }
759 #[bench] fn comparef64_len0087121_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 87121); }
760 #[bench] fn comparef64_len0087121_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 87121); }
761 #[bench] fn comparef64_len0088001_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 88001); }
762 #[bench] fn comparef64_len0088001_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 88001); }
763 #[bench] fn comparef64_len0089101_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 89101); }
764 #[bench] fn comparef64_len0089101_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 89101); }
765 #[bench] fn comparef64_len0092401_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 92401); }
766 #[bench] fn comparef64_len0092401_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 92401); }
767 #[bench] fn comparef64_len0097021_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 97021); }
768 #[bench] fn comparef64_len0097021_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 97021); }
769 #[bench] fn comparef64_len0098011_11p02_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 98011); }
770 #[bench] fn comparef64_len0098011_11p02_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 98011); }
771 #[bench] fn comparef64_len0098561_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 98561); }
772 #[bench] fn comparef64_len0098561_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 98561); }
773 #[bench] fn comparef64_len0099793_11p01_bluesteins(b: &mut Bencher) { bench_planned_bluesteins_f64(b, 99793); }
774 #[bench] fn comparef64_len0099793_11p01_raders(b: &mut Bencher) { bench_planned_raders_f64(b, 99793); }
775
776 */