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