Discrete Fourier Transformation for real-valued input (RDFT)#

Versioned name: RDFT-9

Category: Signal processing

Short description: RDFT operation performs the discrete real-to-complex Fourier transformation of the input tensor by specified dimensions.

Attributes:

No attributes available.

Inputs

1: data - Input tensor of type T with data for the RDFT transformation. Required.
2: axes - 1D tensor of type T_IND specifying dimension indices where RDFT is applied, and axes is any unordered list of indices of different dimensions of input tensor, for example, [0, 4], [4, 0], [4, 2, 1], [1, 2, 3], [-3, 0, -2]. These indices should be integers from -r to r - 1 inclusively, where r = rank(data). A negative axis a is interpreted as an axis r + a. Other dimensions do not change. The order of elements in axes attribute matters, and is mapped directly to elements in the third input signal_size. Required.
3: signal_size - 1D tensor of type T_SIZE describing signal size with respect to axes from the input axes. If signal_size[i] == -1, then RDFT is calculated for full size of the axis axes[i]. If signal_size[i] > data_shape[axes[i]], then input data is zero-padded with respect to the axis axes[i] at the end. Finally, signal_size[i] < data_shape[axes[i]], then input data is trimmed with respect to the axis axes[i]. More precisely, if signal_size[i] < data_shape[axes[i]], the slice 0: signal_size[i] of the axis axes[i] is considered. Optionally, with default value [data_shape[a] for a in axes].
NOTE: If the input signal_size is specified, the size of signal_size must be the same as the size of axes.

Outputs

1: Resulting tensor with elements of the same type as input data tensor and with rank r + 1, where r = rank(data). The shape of the output has the form [S_0, S_1, ..., S_{r-1}, 2], where all S_a are calculated as follows:

Calculate normalized_axes, where each normalized_axes[i] = axes[i], if axes[i] >= 0, and normalized_axes[i] = axes[i] + r otherwise.
If a not in normalized_axes, then S_a = data_shape[a].
If a in normalized_axes, then a = normalized_axes[i] for some i.
- When i != len(normalized_axes) - 1, S_a is calculated as S_a = data_shape[a] if the signal_size input is not specified, or, if it is specified, signal_size[i] = -1; and S_a = signal_size[a] otherwise.
- When i = len(normalized_axes) - 1, S_a is calculated as S_a = data_shape[a] // 2 + 1 if the signal_size input is not specified, or, if it is specified, signal_size[i] = -1; and S_a = signal_size[a] // 2 + 1 otherwise.

Types

T: any supported floating-point type.
T_IND: int64 or int32.
T_SIZE: int64 or int32.

Detailed description: RDFT performs the discrete Fourier transformation of real-valued input tensor with respect to specified axes. Calculations are performed according to the following rules.

For simplicity, assume that an input tensor A has the shape [B_0, ..., B_{k-1}, M_0, ..., M_{q-1}], axes=[k,...,k+q-1], and signal_size=[S_0,...,S_{q-1}].

Let D be an input tensor A, taking into account the signal_size, and, hence, D has the shape [B_0, ..., B_{k-1}, S_0, ..., S_{q-1}].

Next, let

\[X=X[j_0,\dots,j_{k-1},j_k,\dots,j_{k+q-1}]\]

for all indices j_0,...,j_{k+q-1}, be a real-valued input tensor.

Then the transformation RDFT of the tensor X is the tensor Y of the shape [B_0, ..., B_{k-1}, S_0 // 2 + 1, ..., S_{r-1} // 2 + 1], such that

\[Y[n_0,\dots,n_{k-1},m_0,\dots,m_{q-1}]=\sum\limits_{j_0=0}^{S_0-1}\cdots\sum\limits_{j_{q-1}=0}^{S_{q-1}-1}X[n_0,\dots,n_{k-1},j_0,\dots,j_{q-1}]\exp\left(-2\pi i\sum\limits_{b=0}^{q-1}\frac{m_bj_b}{S_b}\right)\]

for all indices n_0,...,n_{k-1}, m_0,...,m_{q-1}.

Calculations for the generic case of axes and signal sizes are similar.

Example:

There is no signal_size input (3D input tensor):

 <layer ... type="RDFT" ... >
     <input>
         <port id="0">
             <dim>1</dim>
             <dim>320</dim>
             <dim>320</dim>
         </port>
         <port id="1">
             <dim>2</dim> <!-- axes input contains [1, 2] -->
         </port>
     <output>
         <port id="2">
             <dim>1</dim>
             <dim>320</dim>
             <dim>161</dim>
             <dim>2</dim>
         </port>
     </output>
 </layer>

There is no signal_size input (2D input tensor):

 <layer ... type="RDFT" ... >
     <input>
         <port id="0">
             <dim>320</dim>
             <dim>320</dim>
         </port>
         <port id="1">
             <dim>2</dim> <!-- axes input contains [0, 1] -->
         </port>
     <output>
         <port id="2">
             <dim>320</dim>
             <dim>161</dim>
             <dim>2</dim>
         </port>
     </output>
 </layer>

There is signal_size input (3D input tensor):

 <layer ... type="RDFT" ... >
     <input>
         <port id="0">
             <dim>1</dim>
             <dim>320</dim>
             <dim>320</dim>
         </port>
         <port id="1">
             <dim>2</dim> <!-- axes input contains [1, 2] -->
         </port>
         <port id="2">
             <dim>2</dim> <!-- signal_size input contains [512, 100] -->
         </port>
     <output>
         <port id="3">
             <dim>1</dim>
             <dim>512</dim>
             <dim>51</dim>
             <dim>2</dim>
         </port>
     </output>
 </layer>

There is signal_size input (2D input tensor):

 <layer ... type="RDFT" ... >
     <input>
         <port id="0">
             <dim>320</dim>
             <dim>320</dim>
         </port>
         <port id="1">
             <dim>2</dim> <!-- axes input contains [0, 1] -->
         </port>
         <port id="2">
             <dim>2</dim> <!-- signal_size input contains [512, 100] -->
         </port>
     <output>
         <port id="3">
             <dim>512</dim>
             <dim>51</dim>
             <dim>2</dim>
         </port>
     </output>
 </layer>

There is signal_size input (4D input tensor, -1 in signal_size, unsorted axes):

 <layer ... type="RDFT" ... >
     <input>
         <port id="0">
             <dim>16</dim>
             <dim>768</dim>
             <dim>580</dim>
             <dim>320</dim>
         </port>
         <port id="1">
             <dim>3</dim> <!-- axes input contains  [3, 1, 2] -->
         </port>
         <port id="2">
             <dim>3</dim> <!-- signal_size input contains [170, -1, 1024] -->
         </port>
     <output>
         <port id="3">
             <dim>16</dim>
             <dim>768</dim>
             <dim>513</dim>
             <dim>170</dim>
             <dim>2</dim>
         </port>
     </output>
 </layer>

There is signal_size input (4D input tensor, -1 in signal_size, unsorted axes, the second example):

 <layer ... type="RDFT" ... >
     <input>
         <port id="0">
             <dim>16</dim>
             <dim>768</dim>
             <dim>580</dim>
             <dim>320</dim>
         </port>
         <port id="1">
             <dim>3</dim> <!-- axes input contains  [3, 0, 2] -->
         </port>
         <port id="2">
             <dim>3</dim> <!-- signal_size input contains [258, -1, 2056] -->
         </port>
     <output>
         <port id="3">
             <dim>16</dim>
             <dim>768</dim>
             <dim>1029</dim>
             <dim>258</dim>
             <dim>2</dim>
         </port>
     </output>
 </layer>