public static double[] Transform(double[] functionPoints, string transformate)
{
var copyofFunctionsPoints = functionPoints;
switch (transformate)
{
case "FFT":
var complexArray = Array.ConvertAll(copyofFunctionsPoints, x => new Complex(x, 0));
FourierTransform.DFT(complexArray, FourierTransform.Direction.Forward);
copyofFunctionsPoints = Array.ConvertAll(complexArray, z => z.Real);
break;
case "IFFT":
var complexArray2 = Array.ConvertAll(copyofFunctionsPoints, x => new Complex(x, 0));
FourierTransform.DFT(complexArray2, FourierTransform.Direction.Backward);
copyofFunctionsPoints = Array.ConvertAll(complexArray2, z => z.Real);
break;
case "DST":
SineTransform.DST(copyofFunctionsPoints);
break;
case "IDST":
SineTransform.IDST(copyofFunctionsPoints);
break;
case "DCT":
CosineTransform.DCT(copyofFunctionsPoints);
break;
case "IDCT":
CosineTransform.IDCT(copyofFunctionsPoints);
break;
case "DHT":
HartleyTransform.DHT(copyofFunctionsPoints);
break;
case "FHT":
HilbertTransform.FHT(copyofFunctionsPoints,
FourierTransform.Direction.Forward);
break;
case "IFHT":
HilbertTransform.FHT(copyofFunctionsPoints,
FourierTransform.Direction.Backward);
break;
default:
throw new ArgumentException("Unknown transformation!");
}
return(copyofFunctionsPoints); //athenia programuje//dididididi//di/kocham PaciA// JJKAKAKK K
}
/// <summary>
/// Applies backward Hilbert transformation to the complex signal.
/// </summary>
public void BackwardHilbertTransform()
{
if (status == ComplexSignalStatus.Analytic)
{
for (int c = 0; c < Channels; c++)
{
Complex[] channel = GetChannel(c);
HilbertTransform.FHT(channel, FourierTransform.Direction.Backward);
SetChannel(c, channel);
}
status = ComplexSignalStatus.Normal;
}
}
/// <summary>
/// Applies forward Hilbert transformation to the complex signal.
/// </summary>
public void ForwardHilbertTransform()
{
if (status == ComplexSignalStatus.Normal)
{
for (int c = 0; c < Channels; c++)
{
System.Numerics.Complex[] channel = GetChannel(c);
HilbertTransform.FHT(channel, FourierTransform.Direction.Forward);
SetChannel(c, channel);
}
status = ComplexSignalStatus.Analytic;
}
}
public void FHTTest2()
{
double[] original = { -1.0, -0.8, -0.2, -0.1, 0.1, 0.2, 0.8, 1.0 };
double[] actual = (double[])original.Clone();
HilbertTransform.FHT(actual, FourierTransform.Direction.Forward);
HilbertTransform.FHT(actual, FourierTransform.Direction.Backward);
Assert.AreEqual(actual[0], original[0], 0.08);
Assert.AreEqual(actual[1], original[1], 0.08);
Assert.AreEqual(actual[2], original[2], 0.08);
Assert.AreEqual(actual[3], original[3], 0.08);
}
public double[] hilbertTransformBaseBand(double[] input)
{
int lengthIn = input.Length;
if (lengthIn > 16384)
{
MessageBox.Show("Error: Input Length Too large or hilbert transform. Data will not be transformed.", "Warning", MessageBoxButton.OK, MessageBoxImage.Error);//For gui, convert this to an error box.
return(null);
}
else
{
int power = (int)Math.Ceiling(Math.Log10(lengthIn) / Math.Log10(2));
int lengthFiller = (int)Math.Pow(2, power) - (int)lengthIn;
double[] fillerArray = MathNet.Numerics.Generate.Step(lengthFiller, 0.0, 0);
Array.Resize <double>(ref input, lengthIn + lengthFiller);
Array.Copy(fillerArray, 0, input, lengthIn, lengthFiller);
HilbertTransform.FHT(input, FourierTransform.Direction.Forward);
return(input);
}
}
public static object FHT(double[] Data, object BackwardFlagOpt)
{
bool backwards = Utils.GetOptionalParameter(BackwardFlagOpt, false);
FourierTransform.Direction direction = (backwards ? FourierTransform.Direction.Backward : FourierTransform.Direction.Forward);
try
{
HilbertTransform.FHT(Data, direction);
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
}
double[,] ret = new double[Data.Length, 1];
for (int i = 0; i < Data.Length; ++i)
{
ret[i, 0] = Data[i];
}
return(ret);
}
public void FHTTest()
{
Complex[] original = { (Complex)1, (Complex)2, (Complex)3, (Complex)4 };
Complex[] actual = (Complex[])original.Clone();
HilbertTransform.FHT(actual, FourierTransform.Direction.Forward);
Assert.AreEqual(actual[0].Re, 1);
Assert.AreEqual(actual[1].Re, 2);
Assert.AreEqual(actual[2].Re, 3);
Assert.AreEqual(actual[3].Re, 4);
Assert.AreEqual(actual[0].Im, +1, 0.000000001);
Assert.AreEqual(actual[1].Im, -1, 0.000000001);
Assert.AreEqual(actual[2].Im, -1, 0.000000001);
Assert.AreEqual(actual[3].Im, +1, 0.000000001);
HilbertTransform.FHT(actual, FourierTransform.Direction.Backward);
Assert.AreEqual(actual[0], original[0]);
Assert.AreEqual(actual[1], original[1]);
Assert.AreEqual(actual[2], original[2]);
Assert.AreEqual(actual[3], original[3]);
}
public static Complex[] Transform(Complex[] functionPoints, string transformate)
{
var copyofFunctionsPoints = functionPoints;
var copyofFunctionsPoints2 = new Complex[functionPoints.Length];
var multidimensialArray = new double[functionPoints.Length, 2];
var jaggedArray = new double[functionPoints.Length][];
for (var i = 0; i < functionPoints.Length; i++)
{
jaggedArray[i] = new double[2];
}
for (var i = 0; i < functionPoints.Length; i++)
{
jaggedArray[i][0] = multidimensialArray[i, 0] = functionPoints[i].Real;
jaggedArray[i][1] =
multidimensialArray[i, 1] = functionPoints[i].Imaginary;
copyofFunctionsPoints2[i] = new Complex(functionPoints[i].Real,
copyofFunctionsPoints2[i].Imaginary);
}
switch (transformate)
{
case "FFT":
Fourier.Forward(copyofFunctionsPoints);
break;
case "IFFT":
Fourier.Inverse(copyofFunctionsPoints);
break;
case "DST":
SineTransform.DST(jaggedArray);
copyofFunctionsPoints = jaggedToComplex(jaggedArray);
break;
case "IDST":
SineTransform.IDST(jaggedArray);
copyofFunctionsPoints = jaggedToComplex(jaggedArray);
break;
case "DCT":
CosineTransform.DCT(multidimensialArray);
copyofFunctionsPoints = multidimensialToComplex(multidimensialArray);
break;
case "IDCT":
CosineTransform.IDCT(multidimensialArray);
copyofFunctionsPoints = multidimensialToComplex(multidimensialArray);
break;
case "DHT":
HartleyTransform.DHT(multidimensialArray);
copyofFunctionsPoints = multidimensialToComplex(multidimensialArray);
break;
case "FHT":
HilbertTransform.FHT(copyofFunctionsPoints2,
FourierTransform.Direction.Forward);
copyofFunctionsPoints = copyofFunctionsPoints2;
break;
case "IFHT":
HilbertTransform.FHT(copyofFunctionsPoints2,
FourierTransform.Direction.Backward);
copyofFunctionsPoints = copyofFunctionsPoints2;
break;
default:
throw new ArgumentException("Unknown transformation!");
}
return(copyofFunctionsPoints); //athenia programuje//dididididi//di/kocham PaciA// JJKAKAKK K
}