| AI Engine Intrinsics User Guide (AIE) v2025.2

Loading...
Searching...
No Matches
FFT intrinsics
Intrinsics » Application Specific Intrinsics

## Overview

These are the intrinsics functions used for implementing FFT functionality.

For intrinsics used for addressing related to FFT please see FFT addressing.

The FFT algorithm works by executing these functions a number of times in different stages.

The number of stages is the log of the number of points in the FFT with the radix as the base of the log. For instance for a 256 point radix 2 FFT the process is split into 8 stages. The first 6 stages are the same and consist of calling the butterfly function on every input value that is supplied to it, these input values depend on the radix. In this instance (radix 2) means that every second block is processed. The input pointer is determined by by an incrementation function fft_data_incr. The twiddle values are determined by the use of two functions fft_permute_incr which determines which values within the register to use and fft_twiddle_incr which increments the pointer to the twiddle factors, thereby providing a fresh set of twiddle values.

The output of each stage becomes the input of the next stage.

The last two stages differ from the initial 6 stages in the way that the inputs are twiddles are mapped from the registers and how often the twiddles are updated from the registers.

In the case of radix 2, 256 point FFT with 32bit data, a stage will consist of 32 butterfly calls, each consuming 8 samples, 64 store operations and 64 AIE cycles total.

## FFT scalar functions
unsigned | fft_zoffs (umod_t cntwrap, int step, bool wide_twiddle, bool wide_data)
| Change twiddle factor selectors.
umod_t | fft_mod_delay (umod_t cntwrap)
| Delay the count/wrap parameter.

## FFT butterfly intrinsics
The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. The butterfly function performs the following pseudocode: o = a + b*func(z) p = a - b*func(z) return p::o Alternatively, the following pseudo-code can be performed. The intrinsic will be prefixed with half_ in this case: o = b*func(z) p = a + b*func(z) return p::o Where func(z) can be: func(z) = z: the normal mode func(z) = conj(z): conjugate twiddles for inverse fft applications func(z) = -j*z: multiply twiddles with minus imaginary number. Used in radix-4 kernels. func(z) = -j*conj(z): combination of the two above. See each of the following intrinsics for more specific pseudocode.
v8cacc48 | butterfly_dit (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, int shft)
v8cacc48 | butterfly_dit_cj (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, int shft)
v8cacc48 | butterfly_dit (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, bool zconj, int shft)
v8cacc48 | half_butterfly_dit (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, int shft)
v8cacc48 | half_butterfly_dit_cj (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, int shft)
v8cacc48 | half_butterfly_dit (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, bool zconj, int shft)
v8cacc48 | half_butterfly_dit (v8cacc48 acc, v8cint32 x, v8cint32 y, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets)
v8cacc48 | half_butterfly_dit_cj (v8cacc48 acc, v8cint32 x, v8cint32 y, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets)
v8cacc48 | half_butterfly_dit (v8cacc48 acc, v8cint32 x, v8cint32 y, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, bool zconj)
v8cacc48 | butterfly_dit_minj (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, int shft)
v8cacc48 | butterfly_dit_cj_minj (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, int shft)
v8cacc48 | butterfly_dit_minj (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, bool zconj, int shft)

## Function Documentation

## ◆ butterfly_dit() [1/2]

v8cacc48 butterfly_dit | ( | v8cint32 | x,
|  | v8cint32 | y,
|  | unsigned int | aoffsets,
|  | unsigned int | boffsets,
|  | v8cint16 | z,
|  | unsigned int | zstart,
|  | unsigned int | zoffsets,
|  | bool | zconj,
|  | int | shft
| ) |  |

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0 = ups(x::y(aoffsets0 ),shift) + x::y(boffsets0 )*( z (zstart + zoffsets0 ));
ups
v16acc48 ups(v16int16 a, int shft)
Definition me_ups.h:86
o1 = ups(x::y(aoffsets1 ),shift) + x::y(boffsets1 )*( z (zstart + zoffsets1 ));
o2 = ups(x::y(aoffsets2 ),shift) + x::y(boffsets2 )*( z (zstart + zoffsets2 ));
o3 = ups(x::y(aoffsets3 ),shift) + x::y(boffsets3 )*( z (zstart + zoffsets3 ));

p0 = ups(x::y(aoffsets0 ),shift) - x::y(boffsets0 )*( z (zstart + zoffsets0 ));
p1 = ups(x::y(aoffsets1 ),shift) - x::y(boffsets1 )*( z (zstart + zoffsets1 ));
p2 = ups(x::y(aoffsets2 ),shift) - x::y(boffsets2 )*( z (zstart + zoffsets2 ));
p3 = ups(x::y(aoffsets3 ),shift) - x::y(boffsets3 )*( z (zstart + zoffsets3 ));

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns
  Output accumulator register.

Parameters

  [in] | x | First input buffer for FFT values.
  [in] | y | Second input buffer for FFT values.
  [in] | boffsets | Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
  [in] | z | Buffer of twiddle values.
  [in] | zstart | Fixed offset to the twiddle value selectors. This must be a compile time constant.
  [in] | zoffsets | Selects the twiddle values from z.
  [in] | zconj | (Optional) twiddle values are conjugated befor multiplication.
  [in] | aoffsets | Selects the values for a from x::y.
  [in] | shft | Upshift value for the values from a before accumulation.

## ◆ butterfly_dit() [2/2]

v8cacc48 butterfly_dit | ( | v8cint32 | x,
|  | v8cint32 | y,
|  | unsigned int | aoffsets,
|  | unsigned int | boffsets,
|  | v8cint16 | z,
|  | unsigned int | zstart,
|  | unsigned int | zoffsets,
|  | int | shft
| ) |  |

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0 = ups(x::y(aoffsets0 ),shift) + x::y(boffsets0 )*( z (zstart + zoffsets0 ));
o1 = ups(x::y(aoffsets1 ),shift) + x::y(boffsets1 )*( z (zstart + zoffsets1 ));
o2 = ups(x::y(aoffsets2 ),shift) + x::y(boffsets2 )*( z (zstart + zoffsets2 ));
o3 = ups(x::y(aoffsets3 ),shift) + x::y(boffsets3 )*( z (zstart + zoffsets3 ));

p0 = ups(x::y(aoffsets0 ),shift) - x::y(boffsets0 )*( z (zstart + zoffsets0 ));
p1 = ups(x::y(aoffsets1 ),shift) - x::y(boffsets1 )*( z (zstart + zoffsets1 ));
p2 = ups(x::y(aoffsets2 ),shift) - x::y(boffsets2 )*( z (zstart + zoffsets2 ));
p3 = ups(x::y(aoffsets3 ),shift) - x::y(boffsets3 )*( z (zstart + zoffsets3 ));

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns
  Output accumulator register.

Parameters

  [in] | x | First input buffer for FFT values.
  [in] | y | Second input buffer for FFT values.
  [in] | boffsets | Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
  [in] | z | Buffer of twiddle values.
  [in] | zstart | Fixed offset to the twiddle value selectors. This must be a compile time constant.
  [in] | zoffsets | Selects the twiddle values from z.
  [in] | zconj | (Optional) twiddle values are conjugated befor multiplication.
  [in] | aoffsets | Selects the values for a from x::y.
  [in] | shft | Upshift value for the values from a before accumulation.

## ◆ butterfly_dit_cj()

v8cacc48 butterfly_dit_cj | ( | v8cint32 | x,
|  | v8cint32 | y,
|  | unsigned int | aoffsets,
|  | unsigned int | boffsets,
|  | v8cint16 | z,
|  | unsigned int | zstart,
|  | unsigned int | zoffsets,
|  | int | shft
| ) |  |

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0 = ups(x::y(aoffsets0 ),shift) + x::y(boffsets0 )*( conj(z) (zstart + zoffsets0 ));
o1 = ups(x::y(aoffsets1 ),shift) + x::y(boffsets1 )*( conj(z) (zstart + zoffsets1 ));
o2 = ups(x::y(aoffsets2 ),shift) + x::y(boffsets2 )*( conj(z) (zstart + zoffsets2 ));
o3 = ups(x::y(aoffsets3 ),shift) + x::y(boffsets3 )*( conj(z) (zstart + zoffsets3 ));

p0 = ups(x::y(aoffsets0 ),shift) - x::y(boffsets0 )*( conj(z) (zstart + zoffsets0 ));
p1 = ups(x::y(aoffsets1 ),shift) - x::y(boffsets1 )*( conj(z) (zstart + zoffsets1 ));
p2 = ups(x::y(aoffsets2 ),shift) - x::y(boffsets2 )*( conj(z) (zstart + zoffsets2 ));
p3 = ups(x::y(aoffsets3 ),shift) - x::y(boffsets3 )*( conj(z) (zstart + zoffsets3 ));

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns
  Output accumulator register.

Parameters

  [in] | x | First input buffer for FFT values.
  [in] | y | Second input buffer for FFT values.
  [in] | boffsets | Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
  [in] | z | Buffer of twiddle values.
  [in] | zstart | Fixed offset to the twiddle value selectors. This must be a compile time constant.
  [in] | zoffsets | Selects the twiddle values from z.
  [in] | zconj | (Optional) twiddle values are conjugated befor multiplication.
  [in] | aoffsets | Selects the values for a from x::y.
  [in] | shft | Upshift value for the values from a before accumulation.

## ◆ butterfly_dit_cj_minj()

v8cacc48 butterfly_dit_cj_minj | ( | v8cint32 | x,
|  | v8cint32 | y,
|  | unsigned int | aoffsets,
|  | unsigned int | boffsets,
|  | v8cint16 | z,
|  | unsigned int | zstart,
|  | unsigned int | zoffsets,
|  | int | shft
| ) |  |

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0 = ups(x::y(aoffsets0 ),shift) + x::y(boffsets0 )*( (-j*conj(z)) (zstart + zoffsets0 ));
o1 = ups(x::y(aoffsets1 ),shift) + x::y(boffsets1 )*( (-j*conj(z)) (zstart + zoffsets1 ));
o2 = ups(x::y(aoffsets2 ),shift) + x::y(boffsets2 )*( (-j*conj(z)) (zstart + zoffsets2 ));
o3 = ups(x::y(aoffsets3 ),shift) + x::y(boffsets3 )*( (-j*conj(z)) (zstart + zoffsets3 ));

p0 = ups(x::y(aoffsets0 ),shift) - x::y(boffsets0 )*( (-j*conj(z)) (zstart + zoffsets0 ));
p1 = ups(x::y(aoffsets1 ),shift) - x::y(boffsets1 )*( (-j*conj(z)) (zstart + zoffsets1 ));
p2 = ups(x::y(aoffsets2 ),shift) - x::y(boffsets2 )*( (-j*conj(z)) (zstart + zoffsets2 ));
p3 = ups(x::y(aoffsets3 ),shift) - x::y(boffsets3 )*( (-j*conj(z)) (zstart + zoffsets3 ));

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns
  Output accumulator register.

Parameters

  [in] | x | First input buffer for FFT values.
  [in] | y | Second input buffer for FFT values.
  [in] | boffsets | Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
  [in] | z | Buffer of twiddle values.
  [in] | zstart | Fixed offset to the twiddle value selectors. This must be a compile time constant.
  [in] | zoffsets | Selects the twiddle values from z.
  [in] | zconj | (Optional) twiddle values are conjugated befor multiplication.
  [in] | aoffsets | Selects the values for a from x::y.
  [in] | shft | Upshift value for the values from a before accumulation.

## ◆ butterfly_dit_minj() [1/2]

v8cacc48 butterfly_dit_minj | ( | v8cint32 | x,
|  | v8cint32 | y,
|  | unsigned int | aoffsets,
|  | unsigned int | boffsets,
|  | v8cint16 | z,
|  | unsigned int | zstart,
|  | unsigned int | zoffsets,
|  | bool | zconj,
|  | int | shft
| ) |  |

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0 = ups(x::y(aoffsets0 ),shift) + x::y(boffsets0 )*( (-j*z) (zstart + zoffsets0 ));
o1 = ups(x::y(aoffsets1 ),shift) + x::y(boffsets1 )*( (-j*z) (zstart + zoffsets1 ));
o2 = ups(x::y(aoffsets2 ),shift) + x::y(boffsets2 )*( (-j*z) (zstart + zoffsets2 ));
o3 = ups(x::y(aoffsets3 ),shift) + x::y(boffsets3 )*( (-j*z) (zstart + zoffsets3 ));

p0 = ups(x::y(aoffsets0 ),shift) - x::y(boffsets0 )*( (-j*z) (zstart + zoffsets0 ));
p1 = ups(x::y(aoffsets1 ),shift) - x::y(boffsets1 )*( (-j*z) (zstart + zoffsets1 ));
p2 = ups(x::y(aoffsets2 ),shift) - x::y(boffsets2 )*( (-j*z) (zstart + zoffsets2 ));
p3 = ups(x::y(aoffsets3 ),shift) - x::y(boffsets3 )*( (-j*z) (zstart + zoffsets3 ));

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns
  Output accumulator register.

Parameters

  [in] | x | First input buffer for FFT values.
  [in] | y | Second input buffer for FFT values.
  [in] | boffsets | Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
  [in] | z | Buffer of twiddle values.
  [in] | zstart | Fixed offset to the twiddle value selectors. This must be a compile time constant.
  [in] | zoffsets | Selects the twiddle values from z.
  [in] | zconj | (Optional) twiddle values are conjugated befor multiplication.
  [in] | aoffsets | Selects the values for a from x::y.
  [in] | shft | Upshift value for the values from a before accumulation.

## ◆ butterfly_dit_minj() [2/2]

v8cacc48 butterfly_dit_minj | ( | v8cint32 | x,
|  | v8cint32 | y,
|  | unsigned int | aoffsets,
|  | unsigned int | boffsets,
|  | v8cint16 | z,
|  | unsigned int | zstart,
|  | unsigned int | zoffsets,
|  | int | shft
| ) |  |

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0 = ups(x::y(aoffsets0 ),shift) + x::y(boffsets0 )*( (-j*z) (zstart + zoffsets0 ));
o1 = ups(x::y(aoffsets1 ),shift) + x::y(boffsets1 )*( (-j*z) (zstart + zoffsets1 ));
o2 = ups(x::y(aoffsets2 ),shift) + x::y(boffsets2 )*( (-j*z) (zstart + zoffsets2 ));
o3 = ups(x::y(aoffsets3 ),shift) + x::y(boffsets3 )*( (-j*z) (zstart + zoffsets3 ));

p0 = ups(x::y(aoffsets0 ),shift) - x::y(boffsets0 )*( (-j*z) (zstart + zoffsets0 ));
p1 = ups(x::y(aoffsets1 ),shift) - x::y(boffsets1 )*( (-j*z) (zstart + zoffsets1 ));
p2 = ups(x::y(aoffsets2 ),shift) - x::y(boffsets2 )*( (-j*z) (zstart + zoffsets2 ));
p3 = ups(x::y(aoffsets3 ),shift) - x::y(boffsets3 )*( (-j*z) (zstart + zoffsets3 ));

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns
  Output accumulator register.

Parameters

  [in] | x | First input buffer for FFT values.
  [in] | y | Second input buffer for FFT values.
  [in] | boffsets | Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
  [in] | z | Buffer of twiddle values.
  [in] | zstart | Fixed offset to the twiddle value selectors. This must be a compile time constant.
  [in] | zoffsets | Selects the twiddle values from z.
  [in] | zconj | (Optional) twiddle values are conjugated befor multiplication.
  [in] | aoffsets | Selects the values for a from x::y.
  [in] | shft | Upshift value for the values from a before accumulation.

## ◆ fft_mod_delay()

umod_t fft_mod_delay | ( | umod_t | cntwrap | ) |

Delay the count/wrap parameter.

Parameters

  cntwrap | Counts the number of FFT wraps. The MSB is the wrap bit itself.

Returns
  Same value as input but delayed by some cycles.

This function is needed in the radix-4 FFT implementations where the cntwrap parameter is generated many cycles before its consumption and hence needs to be delayed.

## ◆ fft_zoffs()

unsigned fft_zoffs | ( | umod_t | cntwrap,
|  | int | step,
|  | bool | wide_twiddle,
|  | bool | wide_data
| ) |  |

Change twiddle factor selectors.

Parameters

  cntwrap | Counts the number of FFT wraps. The MSB is the wrap bit itself.
  step | Range {0..3}. Binary logarithm of the count wrap around (number of wraps per twiddle vector). This must be a compile time constant.
  wide_twiddle | True if a wide 8 lane twiddle vector is used. This must be a compile time constant.
  wide_data | True if a wide 8 lane data vector is used This must be a compile time constant.

Returns
  Coefficient (twiddle) selector value for the butterfly() intrinsic.

Note
  Parameters 'step', 'wide_twiddle' and 'wide_data' must be compile time constants.

The butterfly function chooses which twiddle values from the register to use with which input values, based on the returned zoffs value.

For instance if zoffs = 0x1100 then the first twiddle value is used with in[3] and in[2] and the second twiddle value is used with in[1] and in[0]. Which values in the input register correspond to in[3]-in[0] is determined by a similar mapping process in the butterfly function.

For more information on the intrinsic's behaviour you can check the following pseudocode:

unsigned fft_zoffs_test(int cntwrap, int step, bool wide_twiddle, bool wide_data) {
int out;
switch (step) {
case 0:
if (wide_data == 1)
out = 0x76543210;
break;
case 1:
cntwrap &= 1;
if (wide_data == 0)
out = 4*cntwrap * 0x1111 + 0x3210;
else
out = 4*cntwrap * 0x11111111 + 0x33221100;
break;
case 2:
cntwrap &= 3;
if (wide_data == 0)
out = 2*cntwrap * 0x1111 + 0x1100;
else
out = 2*cntwrap * 0x11111111 + 0x11110000;
break;
case 3:
cntwrap &= 7;
if (wide_data == 0)
out = cntwrap * 0x1111;
else
out = cntwrap * 0x11111111;
break;
}
if (wide_twiddle == 0) {
out &= 0x33333333;
} else {
out &= 0x77777777;
}
return out;
}

The following tables shows the resulting offset's the intrinsic would return when:

## wide_twiddle = wide_data = 0

cntwrap | Stage=3 | Stage=2 | Stage=1
--- | --- | --- | ---
0 | {0,0,0,0} | {0,0,1,1} | {0,1,2,3}
1 | {1,1,1,1} | {2,2,3,3} | {0,1,2,3}
2 | {2,2,2,2} | {0,0,1,1} | {0,1,2,3}
3 | {3,3,3,3} | {2,2,3,3} | {0,1,2,3}
4 | {0,0,0,0} | {0,0,1,1} | {0,1,2,3}
5 | {1,1,1,1} | {2,2,3,3} | {0,1,2,3}
6 | {2,2,2,2} | {0,0,1,1} | {0,1,2,3}
7 | {3,3,3,3} | {2,2,3,3} | {0,1,2,3}

## wide_twiddle = 1, wide_data = 0

cntwrap | Stage = 3 | Stage = 2 | Stage = 1
--- | --- | --- | ---
0 | {0,0,0,0} | {0,0,1,1} | {0,1,2,3}
1 | {1,1,1,1} | {2,2,3,3} | {4,5,6,7}
2 | {2,2,2,2} | {4,4,5,5} | {0,1,2,3}
3 | {3,3,3,3} | {6,6,7,7} | {4,5,6,7}
4 | {4,4,4,4} | {0,0,1,1} | {0,1,2,3}
5 | {5,5,5,5} | {2,2,3,3} | {4,5,6,7}
6 | {6,6,6,6} | {4,4,5,5} | {0,1,2,3}
7 | {7,7,7,7} | {6,6,7,7} | {4,5,6,7}

## wide_twiddle = 0, wide_data = 1

cntwrap | Stage = 3 | Stage = 2 | Stage = 1
--- | --- | --- | ---
0 | {0,0,0,0,0,0,0,0} | {0,0,0,0,1,1,1,1} | {0,0,1,1,2,2,2,3}
1 | {1,1,1,1,1,1,1,1} | {2,2,2,2,3,3,3,3} | {0,0,1,1,2,2,2,3}
2 | {2,2,2,2,1,1,1,1} | {0,0,0,0,1,1,1,1} | {0,0,1,1,2,2,2,3}
3 | {3,3,3,3,3,3,3,3} | {2,2,2,2,3,3,3,3} | {0,0,1,1,2,2,2,3}
4 | {0,0,0,0,0,0,0,0} | {0,0,0,0,1,1,1,1} | {0,0,1,1,2,2,2,3}
5 | {1,1,1,1,1,1,1,1} | {2,2,2,2,3,3,3,3} | {0,0,1,1,2,2,2,3}
6 | {2,2,2,2,1,1,1,1} | {0,0,0,0,1,1,1,1} | {0,0,1,1,2,2,2,3}
7 | {3,3,3,3,3,3,3,3} | {2,2,2,2,3,3,3,3} | {0,0,1,1,2,2,2,3}

## wide_twiddle = 1, wide_data = 1

cntwrap | Stage = 3 | Stage = 2 | Stage = 1 | Stage = 0
--- | --- | --- | --- | ---
0 | {0,0,0,0,0,0,0,0} | {0,0,0,0,1,1,1,1} | {0,0,1,1,2,2,2,3} | {0,1,2,3,4,5,6,7}
1 | {1,1,1,1,1,1,1,1} | {2,2,2,2,3,3,3,3} | {4,4,5,5,6,7,7,7} | {0,1,2,3,4,5,6,7}
2 | {2,2,2,2,1,1,1,1} | {4,4,4,4,5,5,5,5} | {0,0,1,1,2,2,2,3} | {0,1,2,3,4,5,6,7}
3 | {3,3,3,3,3,3,3,3} | {6,6,6,6,7,7,7,7} | {4,4,5,5,6,6,7,7} | {0,1,2,3,4,5,6,7}
4 | {4,4,4,4,4,4,4,4} | {0,0,0,0,1,1,1,1} | {0,0,1,1,2,2,2,3} | {0,1,2,3,4,5,6,7}
5 | {5,5,5,5,5,5,5,5} | {2,2,2,2,3,3,3,3} | {4,4,5,5,6,7,7,7} | {0,1,2,3,4,5,6,7}
6 | {6,6,6,6,6,6,6,6} | {4,4,4,4,5,5,5,5} | {0,0,1,1,2,2,2,3} | {0,1,2,3,4,5,6,7}
7 | {7,7,7,7,7,7,7,7} | {6,6,6,6,7,7,7,7} | {4,4,5,5,6,6,7,7} | {0,1,2,3,4,5,6,7}

## ◆ half_butterfly_dit() [1/4]

v8cacc48 half_butterfly_dit | ( | v8cacc48 | acc,
|  | v8cint32 | x,
|  | v8cint32 | y,
|  | unsigned int | boffsets,
|  | v8cint16 | z,
|  | unsigned int | zstart,
|  | unsigned int | zoffsets
| ) |  |

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0 = x::y(boffsets0 )*( z (zstart + zoffsets0 ));
o1 = x::y(boffsets1 )*( z (zstart + zoffsets1 ));
o2 = x::y(boffsets2 )*( z (zstart + zoffsets2 ));
o3 = x::y(boffsets3 )*( z (zstart + zoffsets3 ));

p0 = acc0 + x::y(boffsets0 )*( z (zstart + zoffsets0 ));
p1 = acc1 + x::y(boffsets1 )*( z (zstart + zoffsets1 ));
p2 = acc2 + x::y(boffsets2 )*( z (zstart + zoffsets2 ));
p3 = acc3 + x::y(boffsets3 )*( z (zstart + zoffsets3 ));

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns
  Output accumulator register.

Parameters

  [in] | x | First input buffer for FFT values.
  [in] | y | Second input buffer for FFT values.
  [in] | boffsets | Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
  [in] | z | Buffer of twiddle values.
  [in] | zstart | Fixed offset to the twiddle value selectors. This must be a compile time constant.
  [in] | zoffsets | Selects the twiddle values from z.
  [in] | zconj | (Optional) twiddle values are conjugated befor multiplication.
  [in] | acc | Direct accumulator values for a.

## ◆ half_butterfly_dit() [2/4]

v8cacc48 half_butterfly_dit | ( | v8cacc48 | acc,
|  | v8cint32 | x,
|  | v8cint32 | y,
|  | unsigned int | boffsets,
|  | v8cint16 | z,
|  | unsigned int | zstart,
|  | unsigned int | zoffsets,
|  | bool | zconj
| ) |  |

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0 = x::y(boffsets0 )*( z (zstart + zoffsets0 ));
o1 = x::y(boffsets1 )*( z (zstart + zoffsets1 ));
o2 = x::y(boffsets2 )*( z (zstart + zoffsets2 ));
o3 = x::y(boffsets3 )*( z (zstart + zoffsets3 ));

p0 = acc0 + x::y(boffsets0 )*( z (zstart + zoffsets0 ));
p1 = acc1 + x::y(boffsets1 )*( z (zstart + zoffsets1 ));
p2 = acc2 + x::y(boffsets2 )*( z (zstart + zoffsets2 ));
p3 = acc3 + x::y(boffsets3 )*( z (zstart + zoffsets3 ));

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns
  Output accumulator register.

Parameters

  [in] | x | First input buffer for FFT values.
  [in] | y | Second input buffer for FFT values.
  [in] | boffsets | Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
  [in] | z | Buffer of twiddle values.
  [in] | zstart | Fixed offset to the twiddle value selectors. This must be a compile time constant.
  [in] | zoffsets | Selects the twiddle values from z.
  [in] | zconj | (Optional) twiddle values are conjugated befor multiplication.
  [in] | acc | Direct accumulator values for a.

## ◆ half_butterfly_dit() [3/4]

v8cacc48 half_butterfly_dit | ( | v8cint32 | x,
|  | v8cint32 | y,
|  | unsigned int | aoffsets,
|  | unsigned int | boffsets,
|  | v8cint16 | z,
|  | unsigned int | zstart,
|  | unsigned int | zoffsets,
|  | bool | zconj,
|  | int | shft
| ) |  |

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0 = x::y(boffsets0 )*( z (zstart + zoffsets0 ));
o1 = x::y(boffsets1 )*( z (zstart + zoffsets1 ));
o2 = x::y(boffsets2 )*( z (zstart + zoffsets2 ));
o3 = x::y(boffsets3 )*( z (zstart + zoffsets3 ));

p0 = ups(x::y(aoffsets0 ),shift) + x::y(boffsets0 )*( z (zstart + zoffsets0 ));
p1 = ups(x::y(aoffsets1 ),shift) + x::y(boffsets1 )*( z (zstart + zoffsets1 ));
p2 = ups(x::y(aoffsets2 ),shift) + x::y(boffsets2 )*( z (zstart + zoffsets2 ));
p3 = ups(x::y(aoffsets3 ),shift) + x::y(boffsets3 )*( z (zstart + zoffsets3 ));

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns
  Output accumulator register.

Parameters

  [in] | x | First input buffer for FFT values.
  [in] | y | Second input buffer for FFT values.
  [in] | boffsets | Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
  [in] | z | Buffer of twiddle values.
  [in] | zstart | Fixed offset to the twiddle value selectors. This must be a compile time constant.
  [in] | zoffsets | Selects the twiddle values from z.
  [in] | zconj | (Optional) twiddle values are conjugated befor multiplication.
  [in] | aoffsets | Selects the values for a from x::y.
  [in] | shft | Upshift value for the values from a before accumulation.

## ◆ half_butterfly_dit() [4/4]

v8cacc48 half_butterfly_dit | ( | v8cint32 | x,
|  | v8cint32 | y,
|  | unsigned int | aoffsets,
|  | unsigned int | boffsets,
|  | v8cint16 | z,
|  | unsigned int | zstart,
|  | unsigned int | zoffsets,
|  | int | shft
| ) |  |

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0 = x::y(boffsets0 )*( z (zstart + zoffsets0 ));
o1 = x::y(boffsets1 )*( z (zstart + zoffsets1 ));
o2 = x::y(boffsets2 )*( z (zstart + zoffsets2 ));
o3 = x::y(boffsets3 )*( z (zstart + zoffsets3 ));

p0 = ups(x::y(aoffsets0 ),shift) + x::y(boffsets0 )*( z (zstart + zoffsets0 ));
p1 = ups(x::y(aoffsets1 ),shift) + x::y(boffsets1 )*( z (zstart + zoffsets1 ));
p2 = ups(x::y(aoffsets2 ),shift) + x::y(boffsets2 )*( z (zstart + zoffsets2 ));
p3 = ups(x::y(aoffsets3 ),shift) + x::y(boffsets3 )*( z (zstart + zoffsets3 ));

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns
  Output accumulator register.

Parameters

  [in] | x | First input buffer for FFT values.
  [in] | y | Second input buffer for FFT values.
  [in] | boffsets | Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
  [in] | z | Buffer of twiddle values.
  [in] | zstart | Fixed offset to the twiddle value selectors. This must be a compile time constant.
  [in] | zoffsets | Selects the twiddle values from z.
  [in] | zconj | (Optional) twiddle values are conjugated befor multiplication.
  [in] | aoffsets | Selects the values for a from x::y.
  [in] | shft | Upshift value for the values from a before accumulation.

## ◆ half_butterfly_dit_cj() [1/2]

v8cacc48 half_butterfly_dit_cj | ( | v8cacc48 | acc,
|  | v8cint32 | x,
|  | v8cint32 | y,
|  | unsigned int | boffsets,
|  | v8cint16 | z,
|  | unsigned int | zstart,
|  | unsigned int | zoffsets
| ) |  |

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0 = x::y(boffsets0 )*( conj(z) (zstart + zoffsets0 ));
o1 = x::y(boffsets1 )*( conj(z) (zstart + zoffsets1 ));
o2 = x::y(boffsets2 )*( conj(z) (zstart + zoffsets2 ));
o3 = x::y(boffsets3 )*( conj(z) (zstart + zoffsets3 ));

p0 = acc0 + x::y(boffsets0 )*( conj(z) (zstart + zoffsets0 ));
p1 = acc1 + x::y(boffsets1 )*( conj(z) (zstart + zoffsets1 ));
p2 = acc2 + x::y(boffsets2 )*( conj(z) (zstart + zoffsets2 ));
p3 = acc3 + x::y(boffsets3 )*( conj(z) (zstart + zoffsets3 ));

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns
  Output accumulator register.

Parameters

  [in] | x | First input buffer for FFT values.
  [in] | y | Second input buffer for FFT values.
  [in] | boffsets | Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
  [in] | z | Buffer of twiddle values.
  [in] | zstart | Fixed offset to the twiddle value selectors. This must be a compile time constant.
  [in] | zoffsets | Selects the twiddle values from z.
  [in] | zconj | (Optional) twiddle values are conjugated befor multiplication.
  [in] | acc | Direct accumulator values for a.

## ◆ half_butterfly_dit_cj() [2/2]

v8cacc48 half_butterfly_dit_cj | ( | v8cint32 | x,
|  | v8cint32 | y,
|  | unsigned int | aoffsets,
|  | unsigned int | boffsets,
|  | v8cint16 | z,
|  | unsigned int | zstart,
|  | unsigned int | zoffsets,
|  | int | shft
| ) |  |

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0 = x::y(boffsets0 )*( conj(z) (zstart + zoffsets0 ));
o1 = x::y(boffsets1 )*( conj(z) (zstart + zoffsets1 ));
o2 = x::y(boffsets2 )*( conj(z) (zstart + zoffsets2 ));
o3 = x::y(boffsets3 )*( conj(z) (zstart + zoffsets3 ));

p0 = ups(x::y(aoffsets0 ),shift) + x::y(boffsets0 )*( conj(z) (zstart + zoffsets0 ));
p1 = ups(x::y(aoffsets1 ),shift) + x::y(boffsets1 )*( conj(z) (zstart + zoffsets1 ));
p2 = ups(x::y(aoffsets2 ),shift) + x::y(boffsets2 )*( conj(z) (zstart + zoffsets2 ));
p3 = ups(x::y(aoffsets3 ),shift) + x::y(boffsets3 )*( conj(z) (zstart + zoffsets3 ));

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns
  Output accumulator register.

Parameters

  [in] | x | First input buffer for FFT values.
  [in] | y | Second input buffer for FFT values.
  [in] | boffsets | Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
  [in] | z | Buffer of twiddle values.
  [in] | zstart | Fixed offset to the twiddle value selectors. This must be a compile time constant.
  [in] | zoffsets | Selects the twiddle values from z.
  [in] | zconj | (Optional) twiddle values are conjugated befor multiplication.
  [in] | aoffsets | Selects the values for a from x::y.
  [in] | shft | Upshift value for the values from a before accumulation.