signal
The DolphinDB signal plugin integrates the powerful and high-performance FFTW3 (Fastest Fourier Transform in the West), offering convenient and efficient Fourier transform computations. This plugin includes various signal processing functions, such as discrete sine transform (DST), discrete cosine transform (DCT), and discrete wavelet transform (DWT). Users can load this plugin in DolphinDB and utilize these signal-processing features.
Installation (with installPlugin
)
Required server version: DolphinDB 2.00.10 or higher.
Supported OS: Linux x86.
Installation Steps:
(1) Use listRemotePlugins to check plugin information in the plugin repository.
Note: For plugins not included in the provided list, you can install through precompiled binaries or compile from source. These files can be accessed from our GitHub repository by switching to the appropriate version branch.
login("admin", "123456")
listRemotePlugins(, "http://plugins.dolphindb.com/plugins/")
(2) Invoke installPlugin for plugin installation.
installPlugin("signal")
(3) Use loadPlugin to load the plugin before using the plugin methods.
loadPlugin("signal")
Method References
dct
Syntax
dct(X)
Details
The method performs a DCT and returns a DOUBLE sequence of the same length as the input vector.
Parameters
- X: An INT or DOUBLE vector indicating the input discrete signal sequence.
dst
Syntax
dst(X)
Details
The method performs a DST and returns a DOUBLE sequence of the same length as the input vector.
Parameters
- X: An INT or DOUBLE vector indicating the input discrete signal sequence.
dwt
Syntax
dwt(X)
Details
The method performs a 1-D DWT and returns a table containing two columns: cA and cD. cA denotes the approximation coefficients, and cD represents the detail coefficients.
Parameters
- X: An INT or DOUBLE vector indicating the input discrete signal sequence.
idwt
Syntax
idwt(X,Y)
Details
The method performs an inverse transformation on cA and cD and returns the signal sequence.
Parameters
- X: An INT or DOUBLE vector indicating cA (approximation coefficients).
- Y: An INT or DOUBLE vector indicating cD (detail coefficients).
dctParallel
Syntax
dctParallel(ds)
Details
The method performs the DCT with distributed implementation and returns the transformed sequence. Due to the potential high system load from multi-threaded parallel computing, avoid using it in multi-threaded environments.
Parameters
- ds: A tuple of data sources indicating the input discrete signal sequence. ds, which can be returned by the sqlDS function, includes several partitions distributed across multiple controllers.
fft
Syntax
fft(X,[n,norm])
Details
The method performs a 1-D FFT (Fast Fourier Transform) and returns a complex vector of length n.
Parameters
- X: A real or complex vector indicating the data to be transformed.
- n (optional): An INT scalar indicating the length of the output vector. The default length is X.
- norm (optional): A STRING scalar indicating the normalization mode. It can take the following values:
- "backward" (default): No normalization.
- "forward": Multiply the result by 1/n.
- "ortho": Multiply the result by 1/sqrt(n).
fft!
Syntax
fft!(X,[n,norm])
Details
The method performs a 1-D FFT (Fast Fourier Transform). Note that the only difference between fft and fft! is that the latter operates in-place, directly modifying the input X. This only occurs when X is a complex vector and its length is not less than n.
Parameters
Refer to fft
.
ifft
Syntax
ifft(X,[n,norm])
Details
The method performs a 1-D IFFT (Inverse Fast Fourier Transform) and returns a complex vector of length n.
Parameters
- X: A real or complex vector indicating the data to be transformed.
- n (optional): An INT scalar indicating the length of the output vector. The default length is X.
- norm (optional): A STRING scalar indicating the normalization mode. It can take the following values:
- "backward" (default): No normalization.
- "forward": Multiply the result by 1/n.
- "ortho": Multiply the result by 1/sqrt(n).
ifft!
Syntax
ifft!(X,[n,norm])
Details
The method performs a 1-D IFFT (Inverse Fast Fourier Transform). Note that the only difference between ifft and ifft! is that the latter operates in-place, directly modifying the input X. This only occurs when X is a complex vector and its length is not less than n.
Parameters
Refer to ifft
.
fft2
Syntax
fft2(X,[s,norm])
Details
The method performs a 2-D FFT (Fast Fourier Transform) and returns a complex matrix.
Parameters
- X: A real or complex matrix indicating the data to be transformed.
- s (optional): A two-element vector containing integers that specify the dimension of the output matrix, with the first element indicating the number of rows and the second element indicating the number of columns. The default dimension is X×X.
- norm (optional): A STRING scalar indicating the normalization mode. It can take the following values:
- "backward" (default): No normalization.
- "forward": Multiply the result by 1/n (n is the number of elements in the matrix).
- "ortho": Multiply the result by 1/sqrt(n).
fft2!
Syntax
fft2!(X,[s,norm])
Details
The method performs a 2-D FFT (Fast Fourier Transform). Note that the only difference between fft2 and fft2! is that the latter operates in-place, directly modifying the input X. This only occurs when X is a complex vector and its length is not less than s.
Parameters
Refer to fft2
.
ifft2
Syntax
ifft2(X,[s,norm])
Details
The method performs a 2-D IFFT (Inverse Fast Fourier Transform) and returns a complex matrix.
Parameters
- X: A real or complex matrix indicating the data to be transformed.
- s (optional): A two-element vector containing integers that specify the dimension of the output matrix, with the first element indicating the number of rows and the second element indicating the number of columns. The default dimension is X×X.
- norm (optional): A STRING scalar indicating the normalization mode. It can take the following values:
- "backward" (default): No normalization.
- "forward": Multiply the result by 1/n (n is the number of elements in the matrix).
- "ortho": Multiply the result by 1/sqrt(n).
ifft2!
Syntax
ifft2!(X,[s,norm])
Details
The method performs a 2-D IFFT (Inverse Fast Fourier Transform). Note that the only difference between ifft2 and ifft2! is that the latter operates in-place, directly modifying the input X. This only occurs when X is a complex vector and its length is not less than s.
Parameters
Refer to ifft2
.
secc
Syntax
secc(data,template,k,[moveout,weight])
Details
The method performs waveform cross-correlation of data and each column of *template. *It returns a matrix with n columns and m rows.
Parameters
- data: A 1-D real vector of length l, indicating the waveform data.
- template: A real-valued matrix with dimensions m×n, where each of the n columns represents a waveform segment of length m. Note that m must be no greater than the length l of data.
- k: An INT scalar. It must be at least 2*m and is recommended to be a power of 2.
- moveout (optional): A DOUBLE vector of length n, indicating time delays. The default value is 0.
- weight (optional): A DOUBLE vector of length n, indicating weights. The default value is 1.
abs
Syntax
abs(data)
Details
The method calculates the magnitude of complex numbers.
- If data is a scalar, it returns a DOUBLE scalar.
- If data is a vector, it returns a DOUBLE vector.
Parameters
- data: A complex scalar or vector indicating the data to be calculated.
mul
Syntax
mul(data, num)
Details
The method performs multiplication on complex numbers. The result retains the same format as the input data.
Parameters
- data: A complex scalar or vector indicating the data to be multiplied.
- num: A DOUBLE scalar indicating the multiplier.
Usage Examples
Example 1. Discrete cosine transform
X = [1,2,3,4]
signal::dct(X)
// output: [5,-2.23044235292127,-2.411540739456585E-7,-0.15851240125353]
Example 2. Discrete sine transform
X = [1,2,3,4]
signal::dst(X)
// output: [15.388417979126893,-6.88190937668141,3.632712081813623,-1.624597646358306]
Example 3. Discrete wavelet transform
X = [1,2,3]
signal::dwt(X)
// output:
cA cD
----------------- ------------------
2.121320343559643 -0.707106781186548
4.949747468305834 -0.707106781186548
Example 4. Inverse discrete wavelet transform
X = [2.121320343559643,4.949747468305834]
Y = [-0.707106781186548,-0.707106781186548]
signal::dwt(x,y)
// output: [1,2,3.000000000000001,4.000000000000001]
Example 5. DctParallel
f1=0..9999
f2=1..10000
t=table(f1,f2)
db = database("dfs://rangedb_data", RANGE, 0 5000 10000)
signaldata = db.createPartitionedTable(t, "signaldata", "f1")
signaldata.append!(t)
signaldata=loadTable(db,"signaldata")
ds=sqlDS(<select * from signaldata >)
loadPlugin("/path/to/PluginSignal.txt")
use signal
signal::dctParallel(ds);
Example 6. Fast Fourier transform
X = [1,2,3,4]
signal::fft(X);
// output: [10+0i,-2+2i,-2+0i,-2-2i]
Example 7. Inverse fast Fourier transform
X = [1,2,3,4]
signal::ifft(X);
// output: [2.5+0i,-0.5-0.5i,-0.5+0i,-0.5+0.5i]
Example 8. 2-D fast Fourier transform
X = matrix([1,2,3,4],[4,3,2,1])
signal::fft2(X);
// output:
#0 #1
----- -----
20+0i 0+0i
0+0i -4+4i
0+0i -4+0i
0+0i -4-4i
Example 9. 2-D inverse fast Fourier transform
X = matrix([1,2,3,4],[4,3,2,1])
signal::ifft2(X);
// output:
#0 #1
------ ---------
2.5+0i 0+0i
0+0i -0.5-0.5i
0+0i -0.5+0i
0+0i -0.5+0.5i
Example 10. Super‐efficient cross‐correlation
x=[1, 2, 1, -1, 0, 3];
y=matrix([1,3,2],[4,1,5]);
signal::secc(x,y,4);
// output:
#0 #1
------------------ -----------------
0.981980506061966 0.692934867183583
0.327326835353989 0.251976315339485
-0.377964473009227 0.327326835353989
0.422577127364258 0.536745040121693