FastHartleyTransform (FsODE)

FsODE

Documentation for 0.0.2

FastHartleyTransform Type

Namespace: Altaxo.Calc.Fourier
Assembly: AltaxoCore.Redist.dll
Base Type: obj

Fast Fourier Transform class based on the Fast Hartley Transform.

Constructors

Constructor	Description
`FastHartleyTransform()` Full Usage: `FastHartleyTransform()`

Static members

Static member	Description
`FastHartleyTransform.CyclicConvolution(src1real, src1imag, src2real, src2imag, resultreal, resultimag, scratchreal, scratchimag, n)` Full Usage: `FastHartleyTransform.CyclicConvolution(src1real, src1imag, src2real, src2imag, resultreal, resultimag, scratchreal, scratchimag, n)` Parameters: src1real : `float[]` - The real part of the first input array (will be destroyed). src1imag : `float[]` - The imaginary part of the first input array (will be destroyed). src2real : `float[]` - The real part of the second input array (will be destroyed). src2imag : `float[]` - The imaginary part of the second input array (will be destroyed). resultreal : `float[]` - The real part of the result. (may be identical with arr1 or arr2). resultimag : `float[]` - The imaginary part of the result (may be identical with arr1 or arr2). scratchreal : `float[]` - A helper array. Must be at least of length n. If null is provided here, a new scatch array will be allocated. scratchimag : `float[]` - A helper array. Must be at least of length n. If null is provided here, a new scatch array will be allocated. n : `int` - The length of the convolution. Has to be equal or smaller than the array size. Has to be a power of 2!	Performs a convolution of two complex arrays which are in splitted form. The input arrays will leave intact. src1real : `float[]` The real part of the first input array (will be destroyed). src1imag : `float[]` The imaginary part of the first input array (will be destroyed). src2real : `float[]` The real part of the second input array (will be destroyed). src2imag : `float[]` The imaginary part of the second input array (will be destroyed). resultreal : `float[]` The real part of the result. (may be identical with arr1 or arr2). resultimag : `float[]` The imaginary part of the result (may be identical with arr1 or arr2). scratchreal : `float[]` A helper array. Must be at least of length n. If null is provided here, a new scatch array will be allocated. scratchimag : `float[]` A helper array. Must be at least of length n. If null is provided here, a new scatch array will be allocated. n : `int` The length of the convolution. Has to be equal or smaller than the array size. Has to be a power of 2!
`FastHartleyTransform.CyclicCorrelation(src1real, src1imag, src2real, src2imag, resultreal, resultimag, n)` Full Usage: `FastHartleyTransform.CyclicCorrelation(src1real, src1imag, src2real, src2imag, resultreal, resultimag, n)` Parameters: src1real : `float[]` - The real part of the first input array (will be destroyed). src1imag : `float[]` - The imaginary part of the first input array (will be destroyed). src2real : `float[]` - The real part of the second input array (will be destroyed). src2imag : `float[]` - The imaginary part of the second input array (will be destroyed). resultreal : `float[]` - The real part of the result. (may be identical with arr1 or arr2). resultimag : `float[]` - The imaginary part of the result (may be identical with arr1 or arr2). n : `int` - The length of the convolution. Has to be equal or smaller than the array size. Has to be a power of 2!	Performs a cyclic correlation of two complex arrays which are in splitted form. The input arrays will leave intact. Two helper arrays of length n are automatially allocated and freed during the operation. src1real : `float[]` The real part of the first input array (will be destroyed). src1imag : `float[]` The imaginary part of the first input array (will be destroyed). src2real : `float[]` The real part of the second input array (will be destroyed). src2imag : `float[]` The imaginary part of the second input array (will be destroyed). resultreal : `float[]` The real part of the result. (may be identical with arr1 or arr2). resultimag : `float[]` The imaginary part of the result (may be identical with arr1 or arr2). n : `int` The length of the convolution. Has to be equal or smaller than the array size. Has to be a power of 2!
`FastHartleyTransform.CyclicCorrelation(src1real, src1imag, src2real, src2imag, resultreal, resultimag, n, scratchreal, scratchimag)` Full Usage: `FastHartleyTransform.CyclicCorrelation(src1real, src1imag, src2real, src2imag, resultreal, resultimag, n, scratchreal, scratchimag)` Parameters: src1real : `float[]` - The real part of the first input array (will be destroyed). src1imag : `float[]` - The imaginary part of the first input array (will be destroyed). src2real : `float[]` - The real part of the second input array (will be destroyed). src2imag : `float[]` - The imaginary part of the second input array (will be destroyed). resultreal : `float[]` - The real part of the result. (may be identical with arr1 or arr2). resultimag : `float[]` - The imaginary part of the result (may be identical with arr1 or arr2). n : `int` - The length of the convolution. Has to be equal or smaller than the array size. Has to be a power of 2! scratchreal : `byref<float[]>` - A helper array. Must be at least of length n. If null is provided here, a new scatch array will be allocated. scratchimag : `byref<float[]>` - A helper array. Must be at least of length n. If null is provided here, a new scatch array will be allocated.	Performs a cyclic correlation of two complex arrays which are in splitted form. The input arrays will leave intact. src1real : `float[]` The real part of the first input array (will be destroyed). src1imag : `float[]` The imaginary part of the first input array (will be destroyed). src2real : `float[]` The real part of the second input array (will be destroyed). src2imag : `float[]` The imaginary part of the second input array (will be destroyed). resultreal : `float[]` The real part of the result. (may be identical with arr1 or arr2). resultimag : `float[]` The imaginary part of the result (may be identical with arr1 or arr2). n : `int` The length of the convolution. Has to be equal or smaller than the array size. Has to be a power of 2! scratchreal : `byref<float[]>` A helper array. Must be at least of length n. If null is provided here, a new scatch array will be allocated. scratchimag : `byref<float[]>` A helper array. Must be at least of length n. If null is provided here, a new scatch array will be allocated.
`FastHartleyTransform.CyclicCorrelationDestructive(src1real, src1imag, src2real, src2imag, resultreal, resultimag, n)` Full Usage: `FastHartleyTransform.CyclicCorrelationDestructive(src1real, src1imag, src2real, src2imag, resultreal, resultimag, n)` Parameters: src1real : `float[]` - The real part of the first input array (will be destroyed). src1imag : `float[]` - The imaginary part of the first input array (will be destroyed). src2real : `float[]` - The real part of the second input array (will be destroyed). src2imag : `float[]` - The imaginary part of the second input array (will be destroyed). resultreal : `float[]` - The real part of the result. (may be identical with arr1 or arr2). resultimag : `float[]` - The imaginary part of the result (may be identical with arr1 or arr2). n : `int` - The length of the convolution. Has to be equal or smaller than the array size. Has to be a power of 2!	Performs a correlation of two comlex arrays which are in splitted form (i.e. real and imaginary part are separate arrays). Attention: the data into the input arrays will be destroyed! src1real : `float[]` The real part of the first input array (will be destroyed). src1imag : `float[]` The imaginary part of the first input array (will be destroyed). src2real : `float[]` The real part of the second input array (will be destroyed). src2imag : `float[]` The imaginary part of the second input array (will be destroyed). resultreal : `float[]` The real part of the result. (may be identical with arr1 or arr2). resultimag : `float[]` The imaginary part of the result (may be identical with arr1 or arr2). n : `int` The length of the convolution. Has to be equal or smaller than the array size. Has to be a power of 2!
`FastHartleyTransform.CyclicCorrelationDestructive(arr1, arr2, resultarr, n)` Full Usage: `FastHartleyTransform.CyclicCorrelationDestructive(arr1, arr2, resultarr, n)` Parameters: arr1 : `float[]` - First array. arr2 : `float[]` - Second array. resultarr : `float[]` - The array that stores the correleation result. n : `int` - Number of points to correlate.	Performes a cyclic correlation between array arr1 and arr2 and stores the result in resultarr. Resultarr must be different from the other two arrays. arr1 : `float[]` First array. arr2 : `float[]` Second array. resultarr : `float[]` The array that stores the correleation result. n : `int` Number of points to correlate.
`FastHartleyTransform.CyclicDestructiveConvolution(data, resp, result, n)` Full Usage: `FastHartleyTransform.CyclicDestructiveConvolution(data, resp, result, n)` Parameters: data : `float[]` - The first input array (the data). resp : `float[]` - The second input array (the response function). result : `float[]` - The result of the convolution. n : `int` - The convolution size. The provided arrays may be larger than n, but of course not smaller.	Performs a cyclic convolution of two real valued arrays. The content of the input arrays is destroyed during this operation. data : `float[]` The first input array (the data). resp : `float[]` The second input array (the response function). result : `float[]` The result of the convolution. n : `int` The convolution size. The provided arrays may be larger than n, but of course not smaller.
`FastHartleyTransform.CyclicDestructiveConvolution(src1real, src1imag, src2real, src2imag, resultreal, resultimag, n)` Full Usage: `FastHartleyTransform.CyclicDestructiveConvolution(src1real, src1imag, src2real, src2imag, resultreal, resultimag, n)` Parameters: src1real : `float[]` - The real part of the first input array (will be destroyed). src1imag : `float[]` - The imaginary part of the first input array (will be destroyed). src2real : `float[]` - The real part of the second input array (will be destroyed). src2imag : `float[]` - The imaginary part of the second input array (will be destroyed). resultreal : `float[]` - The real part of the result. (may be identical with arr1 or arr2). resultimag : `float[]` - The imaginary part of the result (may be identical with arr1 or arr2). n : `int` - The length of the convolution. Has to be equal or smaller than the array size. Has to be a power of 2!	Performs a convolution of two comlex arrays which are in splitted form (i.e. real and imaginary part are separate arrays). Attention: the data into the input arrays will be destroyed! src1real : `float[]` The real part of the first input array (will be destroyed). src1imag : `float[]` The imaginary part of the first input array (will be destroyed). src2real : `float[]` The real part of the second input array (will be destroyed). src2imag : `float[]` The imaginary part of the second input array (will be destroyed). resultreal : `float[]` The real part of the result. (may be identical with arr1 or arr2). resultimag : `float[]` The imaginary part of the result (may be identical with arr1 or arr2). n : `int` The length of the convolution. Has to be equal or smaller than the array size. Has to be a power of 2!
`FastHartleyTransform.CyclicRealConvolution(data, resp, result, n)` Full Usage: `FastHartleyTransform.CyclicRealConvolution(data, resp, result, n)` Parameters: data : `float[]` - The first input array (the data). resp : `float[]` - The second input array (the response function). result : `float[]` - The result of the convolution. n : `int` - The convolution size. The provided arrays may be larger than n, but of course not smaller.	Performs a cyclic convolution of two real valued arrays. The content of the input arrays is leaved intact. data : `float[]` The first input array (the data). resp : `float[]` The second input array (the response function). result : `float[]` The result of the convolution. n : `int` The convolution size. The provided arrays may be larger than n, but of course not smaller.
`FastHartleyTransform.CyclicRealConvolution(data, resp, result, n, scratch)` Full Usage: `FastHartleyTransform.CyclicRealConvolution(data, resp, result, n, scratch)` Parameters: data : `float[]` - The first input array (the data). resp : `float[]` - The second input array (the response function). result : `float[]` - The result of the convolution. n : `int` - The convolution size. The provided arrays may be larger than n, but of course not smaller. scratch : `byref<float[]>` - A helper array of at least size n. If null or a smaller array is provided, a new array will be allocated automatically.	Performs a cyclic convolution of two real valued arrays. The content of the input arrays is leaved intact. data : `float[]` The first input array (the data). resp : `float[]` The second input array (the response function). result : `float[]` The result of the convolution. n : `int` The convolution size. The provided arrays may be larger than n, but of course not smaller. scratch : `byref<float[]>` A helper array of at least size n. If null or a smaller array is provided, a new array will be allocated automatically.
`FastHartleyTransform.FFT(real, imag, n)` Full Usage: `FastHartleyTransform.FFT(real, imag, n)` Parameters: real : `float[]` - The array holding the real part of the values. imag : `float[]` - The array holding the imaginary part of the values. n : `int` - Number of points to transform. Have to be a power of 2 (unchecked!)	Does a fourier transform of 'n' points of the 'real' and 'imag' arrays. real : `float[]` The array holding the real part of the values. imag : `float[]` The array holding the imaginary part of the values. n : `int` Number of points to transform. Have to be a power of 2 (unchecked!)
`FastHartleyTransform.FFT(real, imag, direction)` Full Usage: `FastHartleyTransform.FFT(real, imag, direction)` Parameters: real : `float[]` - The array holding the real part of the values. imag : `float[]` - The array holding the imaginary part of the values. direction : `FourierDirection` - The direction of the Fourier transformation.	Does a fourier transform of 'n' points of the 'real' and 'imag' arrays. real : `float[]` The array holding the real part of the values. imag : `float[]` The array holding the imaginary part of the values. direction : `FourierDirection` The direction of the Fourier transformation.
`FastHartleyTransform.FFT(real, imag, n, direction)` Full Usage: `FastHartleyTransform.FFT(real, imag, n, direction)` Parameters: real : `float[]` - The array holding the real part of the values. imag : `float[]` - The array holding the imaginary part of the values. n : `int` - Number of points to transform. Have to be a power of 2 (unchecked!) direction : `FourierDirection` - The direction of the Fourier transformation.	Does a fourier transform of 'n' points of the 'real' and 'imag' arrays. real : `float[]` The array holding the real part of the values. imag : `float[]` The array holding the imaginary part of the values. n : `int` Number of points to transform. Have to be a power of 2 (unchecked!) direction : `FourierDirection` The direction of the Fourier transformation.
`FastHartleyTransform.FHT(fz, n)` Full Usage: `FastHartleyTransform.FHT(fz, n)` Parameters: fz : `float[]` - The array of points. n : `int` - The number of points, must be a power of two. This precondition is not checked!	Does a hartley transform of 'n' points in the array 'fz'. fz : `float[]` The array of points. n : `int` The number of points, must be a power of two. This precondition is not checked!
`FastHartleyTransform.IFFT(real, imag, n)` Full Usage: `FastHartleyTransform.IFFT(real, imag, n)` Parameters: real : `float[]` - The array holding the real part of the values. imag : `float[]` - The array holding the imaginary part of the values. n : `int` - Number of points to transform. Have to be a power of 2 (unchecked!)	Does an in-place inverse fourier transform of 'n' points of the 'real' and 'imag' arrays. real : `float[]` The array holding the real part of the values. imag : `float[]` The array holding the imaginary part of the values. n : `int` Number of points to transform. Have to be a power of 2 (unchecked!)
`FastHartleyTransform.RealFFT(real, n)` Full Usage: `FastHartleyTransform.RealFFT(real, n)` Parameters: real : `float[]` - The array holding the real values to transform. n : `int` - The number of points to transform. Has to be a power of 2 (unchecked!).	Does a real-valued fourier transform of 'n' points of the 'real' array. The real part of the transform ends up in the first half of the array and the imaginary part of the transform ends up in the second half of the array. real : `float[]` The array holding the real values to transform. n : `int` The number of points to transform. Has to be a power of 2 (unchecked!).
`FastHartleyTransform.RealFFT(real, n, direction)` Full Usage: `FastHartleyTransform.RealFFT(real, n, direction)` Parameters: real : `float[]` - The array holding the real values to transform. n : `int` - The number of points to transform. Has to be a power of 2 (unchecked!). direction : `FourierDirection` - The direction of the Fourier transform.	Does a real-valued fourier transform of 'n' points of the 'real' array. On forward transform, the real part of the transform ends up in the first half of the array and the imaginary part of the transform ends up in the second half of the array. On backward transform, real and imaginary part have to be located in the same way like the result of the forward transform. real : `float[]` The array holding the real values to transform. n : `int` The number of points to transform. Has to be a power of 2 (unchecked!). direction : `FourierDirection` The direction of the Fourier transform.
`FastHartleyTransform.RealFFT(real, direction)` Full Usage: `FastHartleyTransform.RealFFT(real, direction)` Parameters: real : `float[]` - The array holding the real values to transform. direction : `FourierDirection` - The direction of the Fourier transform.	Does a real-valued fourier transform of 'n' points of the 'real' array. On forward transform, the real part of the transform ends up in the first half of the array and the imaginary part of the transform ends up in the second half of the array. On backward transform, real and imaginary part have to be located in the same way like the result of the forward transform. real : `float[]` The array holding the real values to transform. direction : `FourierDirection` The direction of the Fourier transform.
`FastHartleyTransform.RealIFFT(real, n)` Full Usage: `FastHartleyTransform.RealIFFT(real, n)` Parameters: real : `float[]` - The array holding the fourier transform values, which will be transformed back. n : `int` - Number of points to transform. Has to be a power of 2 (unchecked).	Does the inverse of a real-valued fourier transform of 'n' points. real : `float[]` The array holding the fourier transform values, which will be transformed back. n : `int` Number of points to transform. Has to be a power of 2 (unchecked).