/// <summary>
/// Verify matches naive complex.
/// </summary>
/// <param name="samples">Samples count.</param>
/// <param name="maximumError">Maximum error.</param>
/// <param name="naive">Naive transform.</param>
/// <param name="fast">Fast delegate.</param>
private static void VerifyMatchesNaiveComplex(
Complex[] samples,
double maximumError,
Func <Complex[], Complex[]> naive,
Action <Complex[]> fast)
{
var spectrumNaive = naive(samples);
var spectrumFast = new Complex[samples.Length];
samples.CopyTo(spectrumFast, 0);
fast(spectrumFast);
AssertHelpers.AlmostEqualList(spectrumNaive, spectrumFast, maximumError);
}
private static void VerifyMatchesDFT(
double[] samples,
double maximumError,
bool inverse,
Action <Complex[]> dft,
Func <double[], double[]> hartley)
{
var hartleyReal = hartley(samples);
var fourierComplex = Array.ConvertAll(samples, s => new Complex(s, inverse ? -s : s));
dft(fourierComplex);
var fourierReal = Array.ConvertAll(fourierComplex, s => s.Real);
AssertHelpers.AlmostEqualList(fourierReal, hartleyReal, maximumError);
}
/// <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 CanTryParseDoubleSparseVector()
{
var data = new[] { 1.2, 3.4, 5.6e-78 };
var text = String.Format(
"{1}{0}{2}{0}{3}",
CultureInfo.CurrentCulture.TextInfo.ListSeparator,
data[0],
data[1],
data[2]);
SparseVector vector;
var ret = SparseVector.TryParse(text, out vector);
Assert.IsTrue(ret);
AssertHelpers.AlmostEqualList(data, vector.ToArray(), 1e-15);
ret = SparseVector.TryParse(text, CultureInfo.CurrentCulture, out vector);
Assert.IsTrue(ret);
AssertHelpers.AlmostEqualList(data, vector.ToArray(), 1e-15);
}
public void CanTryParseSingleDenseVector()
{
var data = new[] { 1.2f, 3.4f, 5.6e-78f };
var text = String.Format(
"{1}{0}{2}{0}{3}",
CultureInfo.CurrentCulture.TextInfo.ListSeparator,
data[0],
data[1],
data[2]);
DenseVector vector;
var ret = DenseVector.TryParse(text, out vector);
Assert.IsTrue(ret);
AssertHelpers.AlmostEqualList(data, (float[])vector, 1e-15);
ret = DenseVector.TryParse(text, CultureInfo.CurrentCulture, out vector);
Assert.IsTrue(ret);
AssertHelpers.AlmostEqualList(data, (float[])vector, 1e-15);
}
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.AlmostEqualListWithError(samples, 1e-12));
Transform.FourierInverse(work);
AssertHelpers.AlmostEqualList(samples, work, 1e-12);
Transform.FourierInverse(work, FourierOptions.Default);
Assert.IsFalse(work.AlmostEqualListWithError(samples, 1e-12));
Transform.FourierForward(work, FourierOptions.Default);
AssertHelpers.AlmostEqualList(samples, work, 1e-12);
}
