/// <summary>
/// Complex to complex transform.
/// </summary>
static void Example1(int length)
{
Console.Write("Test 1: complex transform ... ");
// Size is 2 * n because we are dealing with complex numbers.
int size = 2 * length;
// Create two managed arrays, possibly misalinged.
var data = Util.GenerateSignal(size);
// Copy to native memory.
var input = new ComplexArray(data);
var output = new ComplexArray(size);
// Create a managed plan as well.
var plan1 = Plan.Create1(length, input, output, Direction.Forward, Options.Estimate);
plan1.Execute();
var plan2 = Plan.Create1(length, output, input, Direction.Backward, Options.Estimate);
plan2.Execute();
Array.Clear(data, 0, data.Length);
// Copy unmanaged output of back-tranform to managed array.
input.CopyTo(data);
// Check and see how we did.
Util.CheckResults(length, length, data);
}
/// <summary>
/// Real to complex transform.
/// </summary>
static void Example2(int length)
{
Console.Write("Test 2: real to complex transform ... ");
int n = length;
// Create two managed arrays, possibly misalinged.
var data = Util.GenerateSignal(n);
// Copy to native memory.
var input = new RealArray(data);
var output = new ComplexArray(n / 2 + 1);
// Create a managed plan.
var plan1 = Plan.Create1(n, input, output, Options.Estimate);
plan1.Execute();
var plan2 = Plan.Create1(n, output, input, Options.Estimate);
plan2.Execute();
Array.Clear(data, 0, n);
// Copy unmanaged output of back-tranform to managed array.
input.CopyTo(data);
// Check and see how we did.
Util.CheckResults(n, n, data);
}
private void getPxxFx(ComplexArray signal, double samplingRate, out DoubleArray Pxx, out DoubleArray Fx)
{
//Implements Matlab's PWelch. Same as [Pxx, Fx] = pwelch(x, w, 0, nfft, Fs), where x = signal, w is calculated below, nfft = signal.count, Fs = samplingRate (hz)
int Nx = signal.Count;
DoubleArray w = DoubleArray.From(hamming(Nx));
double std = w.Std();
double mean = w.Mean();
ComplexArray xw = signal.ElementMultiply(w);
int nfft = Nx;
ComplexArray X = FFTComp.FFTComplex(xw);
DoubleArray absX = X.Abs();
DoubleArray mx = absX.ElementMultiply(absX);
DoubleArray wt = w.Transpose();
double res = w.Multiply(wt)[0];
mx = mx.Divide(res);
int numUniquePts = nfft / 2 + 1;
Slice slice = new Slice(0, numUniquePts - 1);
mx = mx.GetSlice(slice);
double temp1 = mx[0];
double temp2 = mx[mx.Count - 1];
mx = mx.Multiply(2);
mx[0] = temp1;
mx[mx.Count - 1] = temp2;
Pxx = mx.Divide(samplingRate);
Fx = getFx(numUniquePts, samplingRate, nfft);
w.Dispose();
absX.Dispose();
mx.Dispose();
wt.Dispose();
}
/// <summary>
/// Shift (offset) the elements in the array
/// </summary>
/// <param name="array"></param>
/// <param name="offset"></param>
static public void Shift(ComplexF[] array, int offset)
{
Debug.Assert(array != null);
Debug.Assert(offset >= 0);
Debug.Assert(offset < array.Length);
if (offset == 0)
{
return;
}
int length = array.Length;
ComplexF[] workspace = null;
ComplexArray.LockWorkspaceF(length, ref workspace);
for (int i = 0; i < length; i++)
{
workspace[(i + offset) % length] = array[i];
}
for (int i = 0; i < length; i++)
{
array[i] = workspace[i];
}
ComplexArray.UnlockWorkspaceF(ref workspace);
}
public double[] Spectrum(double[] input, bool scale)
{
int length = input.Length;
var zinput = Helper.ToComplex(input);
using (var data1 = new ComplexArray(zinput))
using (var data2 = new ComplexArray(length))
using (var plan1 = Plan.Create1(length, data1, data2, Direction.Forward, Options.Estimate))
using (var plan2 = Plan.Create1(length, data2, data1, Direction.Backward, Options.Estimate))
{
plan1.Execute();
var temp = data2.ToArray();
var spectrum = Helper.ComputeSpectrum(temp);
plan2.Execute();
data1.CopyTo(input, true);
if (scale)
{
for (int i = 0; i < length; i++)
{
input[i] /= length;
}
}
return(spectrum);
}
}
public double[] Spectrum(double[] input, bool scale)
{
int length = input.Length;
using (var data1 = new RealArray(length))
using (var data2 = new ComplexArray(length / 2 + 1))
using (var plan1 = Plan.Create1(length, data1, data2, Options.Estimate))
using (var plan2 = Plan.Create1(length, data2, data1, Options.Estimate))
{
data1.Set(input);
plan1.Execute();
var temp = data2.ToArray();
var spectrum = Helper.ComputeSpectrum(temp);
plan2.Execute();
data1.CopyTo(input);
if (scale)
{
for (int i = 0; i < length; i++)
{
input[i] /= length;
}
}
return(spectrum);
}
}
private void GetPxxFx(ComplexArray signal, out DoubleArray Pxx, out DoubleArray Fx)
{
ComplexArray X = FFTComp.FFTComplex(signal);
Pxx = X.Abs();
Fx = GetFx(signal.Length);
X.Dispose();
}
public FFT(int n)
{
this.N = n;
var size = n * n;
_fftIn = new ComplexArray(size);
_fftOut = new ComplexArray(size);
_fftPlan = fftwf_plan.dft_2d(n, n, _fftIn, _fftOut, fftw_direction.Backward, fftw_flags.Estimate);
_spaceDomain = new float[2 * size];
}
public void Initialize(double[] data)
{
int length = Size = data.Length;
this.data = (double[])data.Clone();
input = new RealArray(data);
output = new ComplexArray(length / 2 + 1);
plan = Plan.Create1(length, input, output, Options.Estimate);
}
public FFT(int n)
{
this.N = n;
var size = n * n;
_fftIn = new ComplexArray(size);
_fftOut = new ComplexArray(size);
_fftPlan = fftwf_plan.dft_2d(n, n, _fftIn, _fftOut, fftw_direction.Backward, fftw_flags.Estimate);
_spaceDomain = new float[2 * size];
}
public FFTStats(Trajectory trajectory, EDirection direction, bool useSlope)
{
var points = (useSlope) ? trajectory.slopes : trajectory.points;
var xList = (direction == EDirection.Z) ? points.Select(p => p.z).ToArray() : points.Select(p => p.x).ToArray();
var zList = (direction == EDirection.X) ? points.Select(p => p.x).ToArray() : points.Select(p => p.z).ToArray();
dataXList = DoubleArray.From(xList);
dataZList = DoubleArray.From(zList);
signal = GetSignal(dataXList, dataZList);
duration = trajectory.duratation();
GetPxxFx(signal, out Pxx, out Fx);
}
public void Initialize(double[] data)
{
int length = Size = data.Length;
this.data = new float[length];
for (int i = 0; i < length; i++)
{
this.data[i] = (float)data[i];
}
input = new RealArray(this.data);
output = new ComplexArray(length / 2 + 1);
plan = Plan.Create1(length, input, output, Options.Estimate);
}
public void Initialize(double[] data)
{
int length = Size = data.Length;
var temp = new double[2 * length];
for (int i = 0; i < length; i++)
{
temp[2 * i] = data[i];
temp[2 * i + 1] = 0.0;
}
input = new ComplexArray(length);
output = new ComplexArray(length);
input.Set(temp);
plan = Plan.Create1(length, input, output, Direction.Forward, Options.Estimate);
}
public FrequencyStats(Trajectory trajectory, bool useSlope = false)
{
var xList = (useSlope) ? trajectory.slopes.Select(p => p.x).ToArray() : trajectory.points.Select(p => p.x).ToArray();
var zList = (useSlope) ? trajectory.slopes.Select(p => p.z).ToArray() : trajectory.points.Select(p => p.z).ToArray();
dataXList = DoubleArray.From(xList);
dataZList = DoubleArray.From(zList);
signal = getSignal(dataXList, dataZList);
getPxxFx(signal, trajectory.samplingRate, out Pxx, out Fx);
//Discard values before 0.05 Hz (high pass filter)
highPassFilter(Pxx, Fx, 0.05, out Pxx, out Fx);
totalPower = Pxx.Sum();
F50 = getFn(Pxx, Fx, 0.5);
F95 = getFn(Pxx, Fx, 0.95);
centroidFreq = getCentroidFreq(Pxx, Fx);
FreqDispersion = getFreqDispersion(Pxx, Fx);
}
public void Construction()
{
int n = 10;
WaveData wd = new WaveData(n);
Assert.AreEqual(n, wd.Length);
n = 24;
double[] arr = new double[n];
wd = new WaveData(arr);
Assert.AreEqual(n, wd.Length);
n = 20;
ComplexArray ca = new ComplexArray(n, false);
wd = new WaveData(ca);
Assert.AreEqual(n + 1, wd.SpLength);
Assert.AreEqual(n * 2, wd.Length);
}
public override object Clone()
{
ComplexArray newObj = new ComplexArray(this);
array.CopyTo(newObj.array, 0);
return newObj;
}
private ComplexArray(ComplexArray c) : base(c)
{
array = new Z.Pointer[c.Count];
}
/// <summary>
/// Multiply each element in target array with corresponding element in rhs array
/// </summary>
/// <param name="target"></param>
/// <param name="rhs"></param>
static public void Multiply(ComplexF[] target, ComplexF[] rhs)
{
ComplexArray.Multiply(target, rhs, target);
}
static void Main(string[] args)
{
//CASE #1
//--Inputs
//---FlatArray:
string[] i11 = new[] { "Islamabad", "lahore", "karachi", "SARGODHA", "mulTan" };
//---ComplexArray:
ComplexArray <string>[] i12 = new ComplexArray <string>[] {
new ComplexArray <string>(
new[] { "islamabad" },
new ComplexArray <string>(new[] { "Lahore" },
new ComplexArray <string>(new[] { "sARGODHA" }))
)
};
//--Operation
string[] case1 = ArrayOperations.MergeElements(i11, i12);
//--Output
Console.WriteLine("----------------------\nCASE #1: \n----------------------");
LogArray(case1);
//CASE #2
//--Inputs
//---FlatArray:
string[] i21 = new[] { "Islamabad", "lahore", "karachi", "SARGODHA", "mulTan" };
//---ComplexArray:
ComplexArray <string>[] i22 = new ComplexArray <string>[] {
new ComplexArray <string>(
new[] { "islamabad" },
new ComplexArray <string>(new[] { "Lahore" },
new ComplexArray <string>(new[] { "guJrat" }))
)
};
//--Operation
(string[] camelCased, string[] lowerCased, string[] upperCased)case2
= ArrayOperations.ExtractCased(i21, i22, requireUnique: false);
//--Output
Console.WriteLine("\n\n----------------------\nCASE #2: \n----------------------");
Console.WriteLine("> Camel Cased: \n-----------");
LogArray(case2.camelCased);
Console.WriteLine("-----------");
Console.WriteLine("> Lower Cased: \n-----------");
LogArray(case2.lowerCased);
Console.WriteLine("-----------");
Console.WriteLine("> Upper Cased: \n-----------");
LogArray(case2.upperCased);
Console.WriteLine("-----------");
//CASE #3
//--Inputs
//---FlatArray:
string[] i31 = new[] { "Islamabad", "lahore", "karachi", "SARGODHA", "guJraT", "mulTan" };
//---ComplexArray:
ComplexArray <string>[] i32 = new ComplexArray <string>[] {
new ComplexArray <string>(
new[] { "islamabad" },
new ComplexArray <string>(new[] { "Lahore" },
new ComplexArray <string>(new[] { "fAiSalaBad" }))
)
};
//--Operation 1:
var case3 = ArrayOperations.MergeCasedAndOrder(i31, i32, requireUnique: false);
//--Output 1
Console.WriteLine("\n\n---------------------------\nCASE #3 (Cased Merge): \n---------------------------");
LogArray(case3);
//--Operation 2:
case3 = case3.SortDescending();
//--Output 2
Console.WriteLine("----------------------\n(Sorted): \n----------------------");
LogArray(case3);
Console.ReadKey();
}
/// <summary>
/// Divide each element in target array with corresponding element in rhs array
/// </summary>
/// <param name="target"></param>
/// <param name="rhs"></param>
static public void Divide(ComplexF[] target, ComplexF[] rhs)
{
ComplexArray.Divide(target, rhs, target);
}
private ComplexArray GetSignal(DoubleArray xList, DoubleArray zList)
{
return(ComplexArray.From(xList, zList));
}
