yFFT: rustfmt

EngineCore/src/yfft/src/benchmark.rs

@@ -22,10 +22,13 @@ fn run_single_benchmark(size: usize, b: &mut Bencher) {
         output_data_format: DataFormat::Complex,
         len: size,
         inverse: false,
-    }).unwrap();
+    })
+    .unwrap();
     let mut senv = Env::new(&setup);
     let mut buf = vec![0f32; size * 2];
-    b.iter(move || { senv.transform(buf.as_mut_slice()); })
+    b.iter(move || {
+        senv.transform(buf.as_mut_slice());
+    })
 }
 
 #[bench]
@@ -97,10 +100,13 @@ fn run_single_real_benchmark(size: usize, b: &mut Bencher) {
         output_data_format: DataFormat::HalfComplex,
         len: size,
         inverse: false,
-    }).unwrap();
+    })
+    .unwrap();
     let mut senv = Env::new(&setup);
     let mut buf = vec![0f32; size];
-    b.iter(move || { senv.transform(buf.as_mut_slice()); })
+    b.iter(move || {
+        senv.transform(buf.as_mut_slice());
+    })
 }
 
 #[bench]
@@ -171,10 +177,13 @@ fn run_dif_benchmark(size: usize, b: &mut Bencher) {
         output_data_format: DataFormat::Complex,
         len: size,
         inverse: false,
-    }).unwrap();
+    })
+    .unwrap();
     let mut senv = Env::new(&setup);
     let mut buf = vec![0f32; size * 2];
-    b.iter(move || { senv.transform(buf.as_mut_slice()); })
+    b.iter(move || {
+        senv.transform(buf.as_mut_slice());
+    })
 }
 
 #[bench]
@@ -206,10 +215,13 @@ fn run_dit_benchmark(size: usize, b: &mut Bencher) {
         output_data_format: DataFormat::Complex,
         len: size,
         inverse: false,
-    }).unwrap();
+    })
+    .unwrap();
     let mut senv = Env::new(&setup);
     let mut buf = vec![0f32; size * 2];
-    b.iter(move || { senv.transform(buf.as_mut_slice()); })
+    b.iter(move || {
+        senv.transform(buf.as_mut_slice());
+    })
 }
 
 #[bench]

EngineCore/src/yfft/src/bin/ysr2-benchmark.rs

@@ -4,8 +4,8 @@
 // This source code is a part of Nightingales.
 //
 extern crate yfft;
-use yfft::{Env, Setup, DataOrder, DataFormat, Options};
 use std::time;
+use yfft::{DataFormat, DataOrder, Env, Options, Setup};
 
 fn duration_to_secs(d: time::Duration) -> f64 {
     d.as_secs() as f64 + d.subsec_nanos() as f64 * 1.0e-9
@@ -82,10 +82,13 @@ fn run_single_benchmark(size: usize) {
         output_data_format: DataFormat::Complex,
         len: size,
         inverse: false,
-    }).unwrap();
+    })
+    .unwrap();
     let mut senv = Env::new(&setup);
     let mut buf = vec![0f32; size * 2];
-    let (iter_time, sd) = benchmark(move || { senv.transform(buf.as_mut_slice()); });
+    let (iter_time, sd) = benchmark(move || {
+        senv.transform(buf.as_mut_slice());
+    });
     let size_f = size as f64;
     let num_fops = size_f * size_f.log2() * 5.0;
     let mflops = num_fops / iter_time * 1.0e-6;

EngineCore/src/yfft/src/env.rs

@@ -3,10 +3,10 @@
 //
 // This source code is a part of Nightingales.
 //
-use std::borrow::Borrow;
-use super::{Setup, Num};
-use num_traits::Zero;
 use super::kernel::KernelParams;
+use super::{Num, Setup};
+use num_traits::Zero;
+use std::borrow::Borrow;
 
 /// Encapsulates the working area required for a transformation.
 #[derive(Debug, Clone)]

EngineCore/src/yfft/src/kernel/accessor.rs

@@ -7,7 +7,7 @@
 //! Defines the `SliceAccessor` type that can be used to bypass bounds checking
 //! on the release builds.
 
-use std::{ops, convert};
+use std::{convert, ops};
 
 #[cfg(not(debug_assertions))]
 use std::slice;

EngineCore/src/yfft/src/kernel/bitreversal.rs

@@ -16,7 +16,6 @@ pub fn new_bit_reversal_kernel<T>(radixes: &[usize]) -> Box<Kernel<T>>
 where
     T: Num,
 {
-
     let len = radixes.iter().product();
     let mut indices = vec![0; len];
 
@@ -45,9 +44,8 @@ where
         }
     }
 
-    unsafe {
-        super::x86::new_x86_bit_reversal_kernel(&indices)
-    }.unwrap_or_else(|| BitReversalKernel::new(indices))
+    unsafe { super::x86::new_x86_bit_reversal_kernel(&indices) }
+        .unwrap_or_else(|| BitReversalKernel::new(indices))
 }
 
 #[derive(Debug)]

EngineCore/src/yfft/src/kernel/generic.rs

@@ -15,28 +15,29 @@
 use super::{Kernel, KernelCreationParams, KernelParams, KernelType, SliceAccessor};
 
 use num_complex::Complex;
-use num_traits::{Zero, One};
 use num_iter::range_step;
+use num_traits::{One, Zero};
 
-use super::super::{Num, complex_from_slice};
-
+use super::super::{complex_from_slice, Num};
 
 pub fn new_generic_kernel<T: 'static>(cparams: &KernelCreationParams) -> Box<Kernel<T>>
 where
     T: Num,
 {
-
     let full_circle = if cparams.inverse { 2 } else { -2 };
     let twiddle_delta = Complex::new(
         Zero::zero(),
-        T::from(cparams.size / cparams.radix / cparams.unit).unwrap() *
-            T::from(full_circle).unwrap() * T::PI() /
-            T::from(cparams.size).unwrap(),
-    ).exp();
+        T::from(cparams.size / cparams.radix / cparams.unit).unwrap()
+            * T::from(full_circle).unwrap()
+            * T::PI()
+            / T::from(cparams.size).unwrap(),
+    )
+    .exp();
     let coef_delta = Complex::new(
         Zero::zero(),
         T::from(full_circle).unwrap() * T::PI() / T::from(cparams.radix).unwrap(),
-    ).exp();
+    )
+    .exp();
 
     match cparams.kernel_type {
         KernelType::Dit => Box::new(GenericDitKernel {

EngineCore/src/yfft/src/kernel/generic2.rs

@@ -13,14 +13,14 @@
 //! According to a benchmark result, this kernel runs about 10x slower than a commercial-level FFT library on a Skylake
 //! machine.
 
+use super::utils::{branch_on_static_params, StaticParams, StaticParamsConsumer};
 use super::{Kernel, KernelCreationParams, KernelParams, KernelType, SliceAccessor};
-use super::utils::{StaticParams, StaticParamsConsumer, branch_on_static_params};
 
 use num_complex::Complex;
-use num_traits::{Zero, One};
 use num_iter::range_step;
+use num_traits::{One, Zero};
 
-use super::super::{Num, mul_pos_i};
+use super::super::{mul_pos_i, Num};
 
 use std::fmt::Debug;
 use std::marker::PhantomData;
@@ -29,8 +29,12 @@ pub fn new_specialized_generic_kernel<T>(cparams: &KernelCreationParams) -> Opti
 where
     T: Num,
 {
-
-    branch_on_static_params(cparams, Factory::<T> { phantom: PhantomData })
+    branch_on_static_params(
+        cparams,
+        Factory::<T> {
+            phantom: PhantomData,
+        },
+    )
 }
 
 struct Factory<T> {
@@ -46,32 +50,37 @@ impl<T: Num> StaticParamsConsumer<Option<Box<Kernel<T>>>> for Factory<T> {
         TSParams: StaticParams,
         T: Num,
     {
-
         let full_circle = if cparams.inverse { 2 } else { -2 };
         let twiddle_delta = Complex::new(
             Zero::zero(),
-            T::from(cparams.size / cparams.radix / cparams.unit).unwrap() *
-                T::from(full_circle).unwrap() * T::PI() /
-                T::from(cparams.size).unwrap(),
-        ).exp();
+            T::from(cparams.size / cparams.radix / cparams.unit).unwrap()
+                * T::from(full_circle).unwrap()
+                * T::PI()
+                / T::from(cparams.size).unwrap(),
+        )
+        .exp();
 
         match cparams.radix {
-            2 => Some(Box::new(
-                SpecializedGenericDitKernel::<T, SmallFFT2<T>, TSParams> {
-                    cparams: *cparams,
-                    twiddle_delta: twiddle_delta,
-                    small_fft: PhantomData,
-                    sparams: sparams,
-                },
-            )),
-            4 => Some(Box::new(
-                SpecializedGenericDitKernel::<T, SmallFFT4<T>, TSParams> {
-                    cparams: *cparams,
-                    twiddle_delta: twiddle_delta,
-                    small_fft: PhantomData,
-                    sparams: sparams,
-                },
-            )),
+            2 => Some(Box::new(SpecializedGenericDitKernel::<
+                T,
+                SmallFFT2<T>,
+                TSParams,
+            > {
+                cparams: *cparams,
+                twiddle_delta: twiddle_delta,
+                small_fft: PhantomData,
+                sparams: sparams,
+            })),
+            4 => Some(Box::new(SpecializedGenericDitKernel::<
+                T,
+                SmallFFT4<T>,
+                TSParams,
+            > {
+                cparams: *cparams,
+                twiddle_delta: twiddle_delta,
+                small_fft: PhantomData,
+                sparams: sparams,
+            })),
             _ => None,
         }
     }
@@ -202,14 +211,15 @@ struct SpecializedGenericDitKernel<T, TSmallFFT, TSParams> {
 }
 
 impl<T, TSmallFFT, TSParams> Kernel<T> for SpecializedGenericDitKernel<T, TSmallFFT, TSParams>
-    where T : Num,
-          TSmallFFT : SmallFFT<T>,
-          TSParams : StaticParams {
-
+where
+    T: Num,
+    TSmallFFT: SmallFFT<T>,
+    TSParams: StaticParams,
+{
     fn transform(&self, params: &mut KernelParams<T>) {
         let cparams = &self.cparams;
         let sparams = &self.sparams;
-        let mut data = unsafe { SliceAccessor::new(&mut params.coefs[0 .. cparams.size * 2]) };
+        let mut data = unsafe { SliceAccessor::new(&mut params.coefs[0..cparams.size * 2]) };
 
         let twiddle_delta = self.twiddle_delta;
         let mut small_fft = TSmallFFT::default();
@@ -222,7 +232,7 @@ impl<T, TSmallFFT, TSParams> Kernel<T> for SpecializedGenericDitKernel<T, TSmall
 
         for x in range_step(0, cparams.size, cparams.unit * radix) {
             let mut twiddle_1: Complex<T> = Complex::one();
-            for y in 0 .. cparams.unit {
+            for y in 0..cparams.unit {
                 small_fft.load(&data, (x + y) * 2, cparams.unit * 2);
 
                 if pre_twiddle {

EngineCore/src/yfft/src/kernel/mod.rs

@@ -4,8 +4,8 @@
 // This source code is a part of Nightingales.
 //
 mod accessor;
-mod convert;
 mod bitreversal;
+mod convert;
 mod generic;
 mod generic2;
 mod realfft;
@@ -31,8 +31,8 @@ mod x86 {
     }
 }
 
-use std::fmt::Debug;
 use super::Num;
+use std::fmt::Debug;
 
 use self::accessor::SliceAccessor;
 

EngineCore/src/yfft/src/kernel/realfft.rs

@@ -5,7 +5,7 @@
 //
 use super::{Kernel, KernelParams, SliceAccessor};
 
-use {mul_pos_i, Num, Complex};
+use {mul_pos_i, Complex, Num};
 
 /// Creates a real FFT post-processing or backward real FFT pre-processing kernel.
 pub fn new_real_fft_pre_post_process_kernel<T>(len: usize, inverse: bool) -> Box<Kernel<T>>
@@ -33,7 +33,8 @@ where
         let c = Complex::new(
             T::zero(),
             T::from(i).unwrap() * -T::PI() / T::from(len / 2).unwrap(),
-        ).exp();
+        )
+        .exp();
 
         let a = (Complex::new(T::one(), T::zero()) - mul_pos_i(c)) * half;
         let b = (Complex::new(T::one(), T::zero()) + mul_pos_i(c)) * half;

EngineCore/src/yfft/src/kernel/utils.rs

@@ -3,9 +3,9 @@
 //
 // This source code is a part of Nightingales.
 //
-use super::{Kernel, KernelType, KernelCreationParams, KernelParams};
-use std::{fmt, ptr};
+use super::{Kernel, KernelCreationParams, KernelParams, KernelType};
 use std::any::Any;
+use std::{fmt, ptr};
 
 pub trait StaticParams: fmt::Debug + 'static + Sync + Send {
     fn inverse(&self) -> bool;
@@ -77,7 +77,6 @@ pub fn branch_on_static_params<F, T>(cparams: &KernelCreationParams, f: F) -> T
 where
     F: StaticParamsConsumer<T>,
 {
-
     match (cparams.kernel_type, cparams.inverse) {
         (KernelType::Dit, false) => f.consume(cparams, StaticParamsDitForward {}),
         (KernelType::Dif, false) => f.consume(cparams, StaticParamsDifForward {}),

EngineCore/src/yfft/src/kernel/x86/bitreversal.rs

@@ -3,9 +3,9 @@
 //
 // This source code is a part of Nightingales.
 //
-use super::{Kernel, KernelParams, SliceAccessor};
-use super::utils::{if_compatible, AlignReqKernelWrapper, AlignReqKernel, AlignInfo};
 use super::super::Num;
+use super::utils::{if_compatible, AlignInfo, AlignReqKernel, AlignReqKernelWrapper};
+use super::{Kernel, KernelParams, SliceAccessor};
 
 use simd::x86::sse2::u64x2;
 
@@ -16,9 +16,11 @@ where
     T: Num,
 {
     if_compatible(|| {
-        Some(Box::new(AlignReqKernelWrapper::new(
-            SseDWordBitReversalKernel { indices: indices.clone() },
-        )) as Box<Kernel<f32>>)
+        Some(
+            Box::new(AlignReqKernelWrapper::new(SseDWordBitReversalKernel {
+                indices: indices.clone(),
+            })) as Box<Kernel<f32>>,
+        )
     })
 }