public void NaiveMatchesDft(HartleyOptions hartleyOptions, FourierOptions fourierOptions) { var dht = new DiscreteHartleyTransform(); var samples = SignalGenerator.Random(x => x, GetUniform(1), 0x80); VerifyMatchesDft( samples, 5, false, s => Transform.FourierForward(s, fourierOptions), s => dht.NaiveForward(s, hartleyOptions)); VerifyMatchesDft( samples, 5, true, s => Transform.FourierInverse(s, fourierOptions), s => dht.NaiveInverse(s, hartleyOptions)); }
public void HartleyDefaultNaiveSatisfiesParsevalsTheorem(int count) { var samples = SignalGenerator.Random(x => x, _uniform, count); var timeSpaceEnergy = (from s in samples select s * s).Mean(); var work = new double[samples.Length]; samples.CopyTo(work, 0); // Default -> Symmetric Scaling var dht = new DiscreteHartleyTransform(); work = dht.NaiveForward(work, HartleyOptions.Default); var frequencySpaceEnergy = (from s in work select s * s).Mean(); Assert.AreEqual(timeSpaceEnergy, frequencySpaceEnergy, 1e-12); }
public void FourierDefaultTransformIsReversible() { var samples = SignalGenerator.Random((u, v) => new Complex(u, v), GetUniform(1), 0x7FFF); var work = new Complex[samples.Length]; samples.CopyTo(work, 0); Transform.FourierForward(work); Assert.IsFalse(work.ListAlmostEqual(samples, 6)); Transform.FourierInverse(work); AssertHelpers.ListAlmostEqual(samples, work, 10); Transform.FourierInverse(work, FourierOptions.Default); Assert.IsFalse(work.ListAlmostEqual(samples, 6)); Transform.FourierForward(work, FourierOptions.Default); AssertHelpers.ListAlmostEqual(samples, work, 10); }
/// <summary> /// Verify if is reversible real. /// </summary> /// <param name="count">Samples count.</param> /// <param name="maximumError">Maximum error value.</param> /// <param name="forward">Forward delegate.</param> /// <param name="inverse">Inverse delegate.</param> private void VerifyIsReversibleReal( int count, double maximumError, Func <double[], double[]> forward, Func <double[], double[]> inverse) { var samples = SignalGenerator.Random(x => x, GetUniform(1), count); var work = new double[samples.Length]; samples.CopyTo(work, 0); work = forward(work); Assert.IsFalse(work.AlmostEqualListWithError(samples, maximumError)); work = inverse(work); AssertHelpers.AlmostEqualList(samples, work, maximumError); }
/// <summary> /// Verify if is reversible complex. /// </summary> /// <param name="count">Samples count.</param> /// <param name="maximumError">Maximum error value.</param> /// <param name="forward">Forward delegate.</param> /// <param name="inverse">Inverse delegate.</param> private void VerifyIsReversibleComplex( int count, double maximumError, Func <Complex[], Complex[]> forward, Func <Complex[], Complex[]> inverse) { var samples = SignalGenerator.Random((u, v) => new Complex(u, v), _uniform, count); var work = new Complex[samples.Length]; samples.CopyTo(work, 0); work = forward(work); Assert.IsFalse(work.AlmostEqualListWithError(samples, maximumError)); work = inverse(work); AssertHelpers.AlmostEqualList(samples, work, maximumError); }
public void Radix2ThrowsWhenNotPowerOfTwo() { var samples = SignalGenerator.Random((u, v) => new Complex(u, v), GetUniform(1), 0x7F); var dft = new DiscreteFourierTransform(); Assert.Throws( typeof(ArgumentException), () => dft.Radix2Forward(samples, FourierOptions.Default)); Assert.Throws( typeof(ArgumentException), () => dft.Radix2Inverse(samples, FourierOptions.Default)); Assert.Throws( typeof(ArgumentException), () => DiscreteFourierTransform.Radix2(samples, -1)); Assert.Throws( typeof(ArgumentException), () => DiscreteFourierTransform.Radix2Parallel(samples, -1)); }