public void FourierRadix2MatchesNaive_RealSine(FourierOptions options)
        {
            var samples = Generate.PeriodicMap(16, w => new Complex(Math.Sin(w), 0), 16, 1.0, Constants.Pi2);

            Verify(samples, 12, options, Fourier.NaiveForward, Fourier.Radix2Forward);
            Verify(samples, 12, options, Fourier.NaiveInverse, Fourier.Radix2Inverse);
        }

        public void FourierRadix2IsReversible(FourierOptions options)
        {
            var samples = Generate.RandomComplex(0x8000, GetUniform(1));
            var work = new Complex[samples.Length];
            samples.CopyTo(work, 0);

            Fourier.Radix2Forward(work, options);
            Assert.IsFalse(work.ListAlmostEqual(samples, 6));

            Fourier.Radix2Inverse(work, options);
            AssertHelpers.AlmostEqual(samples, work, 12);
        }

        public void FourierBluesteinIsReversible(FourierOptions options)
        {
            var dft = new DiscreteFourierTransform();

            var samples = Generate.RandomComplex(0x7FFF, GetUniform(1));
            var work = new Complex[samples.Length];
            samples.CopyTo(work, 0);

            dft.BluesteinForward(work, options);
            Assert.IsFalse(work.ListAlmostEqual(samples, 6));

            dft.BluesteinInverse(work, options);
            AssertHelpers.ListAlmostEqual(samples, work, 10);
        }

        /// <summary>
        /// Rescale FFT-the resulting vector according to the provided convention options.
        /// </summary>
        /// <param name="options">Fourier Transform Convention Options.</param>
        /// <param name="samples">Sample Vector.</param>
        private static void ForwardScaleByOptions(FourierOptions options, Complex[] samples)
        {
            if ((options & FourierOptions.NoScaling) == FourierOptions.NoScaling ||
                (options & FourierOptions.AsymmetricScaling) == FourierOptions.AsymmetricScaling)
            {
                return;
            }

            var scalingFactor = Math.Sqrt(1.0 / samples.Length);
            for (int i = 0; i < samples.Length; i++)
            {
                samples[i] *= scalingFactor;
            }
        }

        public void FourierRadix2IsReversible(FourierOptions options)
        {
            var dft = new DiscreteFourierTransform();

            var samples = SignalGenerator.Random((u, v) => new Complex(u, v), GetUniform(1), 0x8000);
            var work = new Complex[samples.Length];
            samples.CopyTo(work, 0);

            dft.Radix2Forward(work, options);
            Assert.IsFalse(work.ListAlmostEqual(samples, 6));

            dft.Radix2Inverse(work, options);
            AssertHelpers.ListAlmostEqual(samples, work, 12);
        }

        static void Verify(
            Complex[] samples,
            int maximumErrorDecimalPlaces,
            FourierOptions options,
            Func<Complex[], FourierOptions, Complex[]> naive,
            Action<Complex[], FourierOptions> fast)
        {
            var spectrumNaive = naive(samples, options);

            var spectrumFast = new Complex[samples.Length];
            samples.CopyTo(spectrumFast, 0);
            fast(spectrumFast, options);

            AssertHelpers.AlmostEqual(spectrumNaive, spectrumFast, maximumErrorDecimalPlaces);
        }

        public void FourierBluesteinMatchesNaiveOnRandomNonPowerOfTwo(FourierOptions options)
        {
            var dft = new DiscreteFourierTransform();
            var samples = Generate.RandomComplex(0x7F, GetUniform(1));

            VerifyMatchesNaiveComplex(
                samples,
                10,
                s => dft.NaiveForward(s, options),
                s => dft.BluesteinForward(s, options));
            VerifyMatchesNaiveComplex(
                samples,
                10,
                s => dft.NaiveInverse(s, options),
                s => dft.BluesteinInverse(s, options));
        }

        public void FourierBluesteinMatchesNaiveOnRandomNonPowerOfTwo(FourierOptions options)
        {
            var dft = new DiscreteFourierTransform();
            var samples = SignalGenerator.Random((u, v) => new Complex(u, v), GetUniform(1), 0x7F);

            VerifyMatchesNaiveComplex(
                samples,
                1e-12,
                s => dft.NaiveForward(s, options),
                s => dft.BluesteinForward(s, options));
            VerifyMatchesNaiveComplex(
                samples,
                1e-12,
                s => dft.NaiveInverse(s, options),
                s => dft.BluesteinInverse(s, options));
        }

        public void NaiveMatchesDft(HartleyOptions hartleyOptions, FourierOptions fourierOptions)
        {
            var samples = Generate.Random(0x80, GetUniform(1));

            VerifyMatchesDft(
                samples,
                5,
                false,
                s => Fourier.Forward(s, fourierOptions),
                s => Hartley.NaiveForward(s, hartleyOptions));
            VerifyMatchesDft(
                samples,
                5,
                true,
                s => Fourier.Inverse(s, fourierOptions),
                s => Hartley.NaiveInverse(s, hartleyOptions));
        }

        public void FourierBluesteinMatchesNaiveOnRandomPowerOfTwo(FourierOptions options)
        {
            var dft = new DiscreteFourierTransform();
            var samples = Sample.Random((u, v) => new Complex(u, v), _uniform, 0x80);

            VerifyMatchesNaiveComplex(
                samples,
                1e-12,
                s => dft.NaiveForward(s, options),
                s => dft.BluesteinForward(s, options));

            VerifyMatchesNaiveComplex(
                samples,
                1e-12,
                s => dft.NaiveInverse(s, options),
                s => dft.BluesteinInverse(s, options));
        }

        public void FourierRadix2MatchesNaiveOnRealSine(FourierOptions options)
        {
            var dft = new DiscreteFourierTransform();
            var samples = SignalGenerator.EquidistantPeriodic(w => new Complex(Math.Sin(w), 0), Constants.Pi2, 0, 16);

            VerifyMatchesNaiveComplex(
                samples,
                1e-12,
                s => dft.NaiveForward(s, options),
                s => dft.Radix2Forward(s, options));

            VerifyMatchesNaiveComplex(
                samples,
                1e-12,
                s => dft.NaiveInverse(s, options),
                s => dft.Radix2Inverse(s, options));
        }

        public void FourierBluesteinIsReversible(FourierOptions options)
        {
            var dft = new DiscreteFourierTransform();

            VerifyIsReversibleComplex(
                0x7FFF,
                1e-12,
                s =>
                {
                    dft.BluesteinForward(s, options);
                    return s;
                },
                s =>
                {
                    dft.BluesteinInverse(s, options);
                    return s;
                });
        }

        /// <summary>
        /// Rescale the iFFT-resulting vector according to the provided convention options.
        /// </summary>
        /// <param name="options">Fourier Transform Convention Options.</param>
        /// <param name="samples">Sample Vector.</param>
        private static void InverseScaleByOptions(FourierOptions options, Complex[] samples)
        {
            if ((options & FourierOptions.NoScaling) == FourierOptions.NoScaling)
            {
                return;
            }

            var scalingFactor = 1.0 / samples.Length;
            if ((options & FourierOptions.AsymmetricScaling) != FourierOptions.AsymmetricScaling)
            {
                scalingFactor = Math.Sqrt(scalingFactor);
            }

            for (int i = 0; i < samples.Length; i++)
            {
                samples[i] *= scalingFactor;
            }
        }

        public void NaiveMatchesDft(HartleyOptions hartleyOptions, FourierOptions fourierOptions)
        {
            var dht = new DiscreteHartleyTransform();
            var samples = SignalGenerator.Random(x => x, GetUniform(1), 0x80);

            VerifyMatchesDft(
                samples,
                1e-5,
                false,
                s => Transform.FourierForward(s, fourierOptions),
                s => dht.NaiveForward(s, hartleyOptions));
            VerifyMatchesDft(
                samples,
                1e-5,
                true,
                s => Transform.FourierInverse(s, fourierOptions),
                s => dht.NaiveInverse(s, hartleyOptions));
        }

        public void NaiveMatchesDFT(HartleyOptions hartleyOptions, FourierOptions fourierOptions)
        {
            var dht = new DiscreteHartleyTransform();
            var samples = Sample.Random(x => x, _uniform, 0x80);

            VerifyMatchesDFT(
                samples,
                1e-10,
                false,
                s => Transform.FourierForward(s, fourierOptions),
                s => dht.NaiveForward(s, hartleyOptions));

            VerifyMatchesDFT(
                samples,
                1e-10,
                true,
                s => Transform.FourierInverse(s, fourierOptions),
                s => dht.NaiveInverse(s, hartleyOptions));
        }

 /// <summary>
 /// Naive inverse DFT, useful e.g. to verify faster algorithms.
 /// </summary>
 /// <param name="frequencySpace">Frequency-space sample vector.</param>
 /// <param name="options">Fourier Transform Convention Options.</param>
 /// <returns>Corresponding time-space vector.</returns>
 public Complex[] NaiveInverse(Complex[] frequencySpace, FourierOptions options)
 {
     var timeSpace = Naive(frequencySpace, -SignByOptions(options));
     InverseScaleByOptions(options, timeSpace);
     return timeSpace;
 }

 /// <summary>
 /// Naive forward DFT, useful e.g. to verify faster algorithms.
 /// </summary>
 /// <param name="timeSpace">Time-space sample vector.</param>
 /// <param name="options">Fourier Transform Convention Options.</param>
 /// <returns>Corresponding frequency-space vector.</returns>
 public Complex[] NaiveForward(Complex[] timeSpace, FourierOptions options)
 {
     var frequencySpace = Naive(timeSpace, SignByOptions(options));
     ForwardScaleByOptions(options, frequencySpace);
     return frequencySpace;
 }

 /// <summary>
 /// Applies the inverse Fast Fourier Transform (iFFT) to arbitrary-length sample vectors.
 /// </summary>
 /// <param name="samples">Sample vector, where the FFT is evaluated in place.</param>
 /// <param name="options">Fourier Transform Convention Options.</param>
 public static void Inverse(Complex[] samples, FourierOptions options)
 {
     BluesteinInverse(samples, options);
 }

 /// <summary>
 /// Applies the forward Fast Fourier Transform (FFT) to arbitrary-length sample vectors.
 /// </summary>
 /// <param name="samples">Sample vector, where the FFT is evaluated in place.</param>
 /// <param name="options">Fourier Transform Convention Options.</param>
 public static void Forward(Complex[] samples, FourierOptions options)
 {
     BluesteinForward(samples, options);
 }

 /// <summary>
 /// Extract the exponent sign to be used in forward transforms according to the
 /// provided convention options.
 /// </summary>
 /// <param name="options">Fourier Transform Convention Options.</param>
 /// <returns>Fourier series exponent sign.</returns>
 static int SignByOptions(FourierOptions options)
 {
     return (options & FourierOptions.InverseExponent) == FourierOptions.InverseExponent ? 1 : -1;
 }