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));
}