| AI Engine Intrinsics User Guide (v2026.1)

Loading...
Searching...
No Matches
Functions
Float
Intrinsics » Vector Operations » Vector Arithmetic » Advanced

## Overview

Advanced Float Vector Arithmetic Operations. The lane selection scheme is explained after each intrinsic. Note that these intrinsics are a wrapper over the fully configurable fpmac_conf base function, explained here. More information on fpmac_conf can be found @intr_gpvectorfpop here.

## Functions
v8float | fpabs (v16float xbuf, int xstart, unsigned int xoffs)
| Take absolute value for single precision real floating point vectors.
v8float | fpabs (v32float xbuf, int xstart, unsigned int xoffs)
| Take absolute value for single precision real floating point vectors.
v8float | fpabs (v8float xbuf)
| Take absolute value for single precision real floating point vectors.
v8float | fpabs (v8float xbuf, int xstart, unsigned int xoffs)
| Take absolute value for single precision real floating point vectors.
v4cfloat | fpadd (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs)
| Add for single precision complex floating point vectors.
v4cfloat | fpadd (v4cfloat acc, v4cfloat xbuf)
| Add for single precision complex floating point vectors.
v4cfloat | fpadd (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs)
| Add for single precision complex floating point vectors.
v4cfloat | fpadd (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs)
| Add for single precision complex floating point vectors.
v8float | fpadd (v8float acc, v16float xbuf, int xstart, unsigned int xoffs)
| Add for single precision real floating point vectors.
v8float | fpadd (v8float acc, v32float xbuf, int xstart, unsigned int xoffs)
| Add for single precision real floating point vectors.
v8float | fpadd (v8float acc, v8float xbuf)
| Add for single precision real floating point vectors.
v8float | fpadd (v8float acc, v8float xbuf, int xstart, unsigned int xoffs)
| Add for single precision real floating point vectors.
v8float | fpadd_abs (v8float acc, v16float xbuf, int xstart, unsigned int xoffs)
| Take absolute value and add for single precision real floating point vectors.
v8float | fpadd_abs (v8float acc, v32float xbuf, int xstart, unsigned int xoffs)
| Take absolute value and add for single precision real floating point vectors.
v8float | fpadd_abs (v8float acc, v8float xbuf)
| Take absolute value and add for single precision real floating point vectors.
v8float | fpadd_abs (v8float acc, v8float xbuf, int xstart, unsigned int xoffs)
| Take absolute value and add for single precision real floating point vectors.
v4cfloat | fpadd_c (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs)
| Add for single precision complex conjugate floating point vectors.
v4cfloat | fpadd_c (v4cfloat acc, v4cfloat xbuf)
| Add for single precision complex conjugate floating point vectors.
v4cfloat | fpadd_c (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs)
| Add for single precision complex conjugate floating point vectors.
v4cfloat | fpadd_c (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs)
| Add for single precision complex conjugate floating point vectors.
v4cfloat | fpneg (v16cfloat xbuf, int xstart, unsigned int xoffs)
| Negate for single precision complex floating point vectors.
v8float | fpneg (v16float xbuf, int xstart, unsigned int xoffs)
| Negate for single precision real floating point vectors.
v8float | fpneg (v32float xbuf, int xstart, unsigned int xoffs)
| Negate for single precision real floating point vectors.
v4cfloat | fpneg (v4cfloat xbuf)
| Negate for single precision complex floating point vectors.
v4cfloat | fpneg (v4cfloat xbuf, int xstart, unsigned int xoffs)
| Negate for single precision complex floating point vectors.
v4cfloat | fpneg (v8cfloat xbuf, int xstart, unsigned int xoffs)
| Negate for single precision complex floating point vectors.
v8float | fpneg (v8float xbuf)
| Negate for single precision real floating point vectors.
v8float | fpneg (v8float xbuf, int xstart, unsigned int xoffs)
| Negate for single precision real floating point vectors.
v8float | fpneg_abs (v16float xbuf, int xstart, unsigned int xoffs)
| Take absolute value and negate for single precision real floating point vectors.
v8float | fpneg_abs (v32float xbuf, int xstart, unsigned int xoffs)
| Take absolute value and negate for single precision real floating point vectors.
v8float | fpneg_abs (v8float xbuf)
| Take absolute value and negate for single precision real floating point vectors.
v8float | fpneg_abs (v8float xbuf, int xstart, unsigned int xoffs)
| Take absolute value and negate for single precision real floating point vectors.
v4cfloat | fpneg_c (v16cfloat xbuf, int xstart, unsigned int xoffs)
| Negate for single precision complex conjugate floating point vectors.
v4cfloat | fpneg_c (v4cfloat xbuf)
| Negate for single precision complex conjugate floating point vectors.
v4cfloat | fpneg_c (v4cfloat xbuf, int xstart, unsigned int xoffs)
| Negate for single precision complex conjugate floating point vectors.
v4cfloat | fpneg_c (v8cfloat xbuf, int xstart, unsigned int xoffs)
| Negate for single precision complex conjugate floating point vectors.
v4cfloat | fpsub (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs)
| Subtract for single precision complex floating point vectors.
v4cfloat | fpsub (v4cfloat acc, v4cfloat xbuf)
| Subtract for single precision complex floating point vectors.
v4cfloat | fpsub (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs)
| Subtract for single precision complex floating point vectors.
v4cfloat | fpsub (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs)
| Subtract for single precision complex floating point vectors.
v8float | fpsub (v8float acc, v16float xbuf, int xstart, unsigned int xoffs)
| Subtract for single precision real floating point vectors.
v8float | fpsub (v8float acc, v32float xbuf, int xstart, unsigned int xoffs)
| Subtract for single precision real floating point vectors.
v8float | fpsub (v8float acc, v8float xbuf)
| Subtract for single precision real floating point vectors.
v8float | fpsub (v8float acc, v8float xbuf, int xstart, unsigned int xoffs)
| Subtract for single precision real floating point vectors.
v8float | fpsub_abs (v8float acc, v16float xbuf, int xstart, unsigned int xoffs)
| Take absolute value and subtract for single precision real floating point vectors.
v8float | fpsub_abs (v8float acc, v32float xbuf, int xstart, unsigned int xoffs)
| Take absolute value and subtract for single precision real floating point vectors.
v8float | fpsub_abs (v8float acc, v8float xbuf)
| Take absolute value and subtract for single precision real floating point vectors.
v8float | fpsub_abs (v8float acc, v8float xbuf, int xstart, unsigned int xoffs)
| Take absolute value and subtract for single precision real floating point vectors.
v4cfloat | fpsub_c (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs)
| Subtract for single precision complex conjugate floating point vectors.
v4cfloat | fpsub_c (v4cfloat acc, v4cfloat xbuf)
| Subtract for single precision complex conjugate floating point vectors.
v4cfloat | fpsub_c (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs)
| Subtract for single precision complex conjugate floating point vectors.
v4cfloat | fpsub_c (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs)
| Subtract for single precision complex conjugate floating point vectors.

## Function Documentation

## ◆ fpabs() [1/4]

v8float fpabs | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Take absolute value for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = abs(xbuf[xstart + xoffs[i]])
xstart
v16float int xstart
Definition me_vfloat.h:5095
xoffs
v16float int unsigned int xoffs
Definition me_vfloat.h:5097
ret
v8float ret
Definition me_vfloat.h:5099
xbuf
v16float xbuf
Definition me_vfloat.h:5095

Returns
  Result vector.

Parameters

  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpabs() [2/4]

v8float fpabs | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Take absolute value for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = abs(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpabs() [3/4]

v8float fpabs | ( | v8float | xbuf | ) |

Take absolute value for single precision real floating point vectors.

for (i = 0 ; i < 8 ; i++)
ret[i] = abs(xbuf[i])

Returns
  Result vector.

Parameters

  xbuf | Input buffer.

## ◆ fpabs() [4/4]

v8float fpabs | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Take absolute value for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = abs(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpadd() [1/8]

v4cfloat fpadd | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Add for single precision complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = acc[i] + xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpadd() [2/8]

v4cfloat fpadd | ( | v4cfloat | acc,
|  | v4cfloat | xbuf )

Add for single precision complex floating point vectors.

for (i = 0 ; i < 4 ; i++)
ret[i] = acc[i] + xbuf[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.

## ◆ fpadd() [3/8]

v4cfloat fpadd | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Add for single precision complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = acc[i] + xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpadd() [4/8]

v4cfloat fpadd | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Add for single precision complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = acc[i] + xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpadd() [5/8]

v8float fpadd | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Add for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = acc[i] + xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpadd() [6/8]

v8float fpadd | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Add for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = acc[i] + xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpadd() [7/8]

v8float fpadd | ( | v8float | acc,
|  | v8float | xbuf )

Add for single precision real floating point vectors.

for (i = 0 ; i < 8 ; i++)
ret[i] = acc[i] + xbuf[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.

## ◆ fpadd() [8/8]

v8float fpadd | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Add for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = acc[i] + xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpadd_abs() [1/4]

v8float fpadd_abs | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Take absolute value and add for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = acc[i] + abs(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpadd_abs() [2/4]

v8float fpadd_abs | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Take absolute value and add for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = acc[i] + abs(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpadd_abs() [3/4]

v8float fpadd_abs | ( | v8float | acc,
|  | v8float | xbuf )

Take absolute value and add for single precision real floating point vectors.

for (i = 0 ; i < 8 ; i++)
ret[i] = acc[i] + abs(xbuf[i])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.

## ◆ fpadd_abs() [4/4]

v8float fpadd_abs | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Take absolute value and add for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = acc[i] + abs(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpadd_c() [1/4]

v4cfloat fpadd_c | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Add for single precision complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = acc[i] + conj(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpadd_c() [2/4]

v4cfloat fpadd_c | ( | v4cfloat | acc,
|  | v4cfloat | xbuf )

Add for single precision complex conjugate floating point vectors.

for (i = 0 ; i < 4 ; i++)
ret[i] = acc[i] + conj(xbuf[i])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.

## ◆ fpadd_c() [3/4]

v4cfloat fpadd_c | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Add for single precision complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = acc[i] + conj(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpadd_c() [4/4]

v4cfloat fpadd_c | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Add for single precision complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = acc[i] + conj(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg() [1/8]

v4cfloat fpneg | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Negate for single precision complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = - xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg() [2/8]

v8float fpneg | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Negate for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = - xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpneg() [3/8]

v8float fpneg | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Negate for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = - xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpneg() [4/8]

v4cfloat fpneg | ( | v4cfloat | xbuf | ) |

Negate for single precision complex floating point vectors.

for (i = 0 ; i < 4 ; i++)
ret[i] = - xbuf[i]

Returns
  Result vector.

Parameters

  xbuf | Input buffer.

## ◆ fpneg() [5/8]

v4cfloat fpneg | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Negate for single precision complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = - xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg() [6/8]

v4cfloat fpneg | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Negate for single precision complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = - xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg() [7/8]

v8float fpneg | ( | v8float | xbuf | ) |

Negate for single precision real floating point vectors.

for (i = 0 ; i < 8 ; i++)
ret[i] = - xbuf[i]

Returns
  Result vector.

Parameters

  xbuf | Input buffer.

## ◆ fpneg() [8/8]

v8float fpneg | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Negate for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = - xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpneg_abs() [1/4]

v8float fpneg_abs | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Take absolute value and negate for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = - abs(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpneg_abs() [2/4]

v8float fpneg_abs | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Take absolute value and negate for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = - abs(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpneg_abs() [3/4]

v8float fpneg_abs | ( | v8float | xbuf | ) |

Take absolute value and negate for single precision real floating point vectors.

for (i = 0 ; i < 8 ; i++)
ret[i] = - abs(xbuf[i])

Returns
  Result vector.

Parameters

  xbuf | Input buffer.

## ◆ fpneg_abs() [4/4]

v8float fpneg_abs | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Take absolute value and negate for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = - abs(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpneg_c() [1/4]

v4cfloat fpneg_c | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Negate for single precision complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = - conj(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_c() [2/4]

v4cfloat fpneg_c | ( | v4cfloat | xbuf | ) |

Negate for single precision complex conjugate floating point vectors.

for (i = 0 ; i < 4 ; i++)
ret[i] = - conj(xbuf[i])

Returns
  Result vector.

Parameters

  xbuf | Input buffer.

## ◆ fpneg_c() [3/4]

v4cfloat fpneg_c | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Negate for single precision complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = - conj(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_c() [4/4]

v4cfloat fpneg_c | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Negate for single precision complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = - conj(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpsub() [1/8]

v4cfloat fpsub | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Subtract for single precision complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = acc[i] - xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpsub() [2/8]

v4cfloat fpsub | ( | v4cfloat | acc,
|  | v4cfloat | xbuf )

Subtract for single precision complex floating point vectors.

for (i = 0 ; i < 4 ; i++)
ret[i] = acc[i] - xbuf[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.

## ◆ fpsub() [3/8]

v4cfloat fpsub | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Subtract for single precision complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = acc[i] - xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpsub() [4/8]

v4cfloat fpsub | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Subtract for single precision complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = acc[i] - xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpsub() [5/8]

v8float fpsub | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Subtract for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = acc[i] - xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpsub() [6/8]

v8float fpsub | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Subtract for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = acc[i] - xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpsub() [7/8]

v8float fpsub | ( | v8float | acc,
|  | v8float | xbuf )

Subtract for single precision real floating point vectors.

for (i = 0 ; i < 8 ; i++)
ret[i] = acc[i] - xbuf[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.

## ◆ fpsub() [8/8]

v8float fpsub | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Subtract for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = acc[i] - xbuf[xstart + xoffs[i]]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpsub_abs() [1/4]

v8float fpsub_abs | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Take absolute value and subtract for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = acc[i] - abs(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpsub_abs() [2/4]

v8float fpsub_abs | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Take absolute value and subtract for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = acc[i] - abs(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpsub_abs() [3/4]

v8float fpsub_abs | ( | v8float | acc,
|  | v8float | xbuf )

Take absolute value and subtract for single precision real floating point vectors.

for (i = 0 ; i < 8 ; i++)
ret[i] = acc[i] - abs(xbuf[i])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.

## ◆ fpsub_abs() [4/4]

v8float fpsub_abs | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Take absolute value and subtract for single precision real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = acc[i] - abs(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.

## ◆ fpsub_c() [1/4]

v4cfloat fpsub_c | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Subtract for single precision complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = acc[i] - conj(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpsub_c() [2/4]

v4cfloat fpsub_c | ( | v4cfloat | acc,
|  | v4cfloat | xbuf )

Subtract for single precision complex conjugate floating point vectors.

for (i = 0 ; i < 4 ; i++)
ret[i] = acc[i] - conj(xbuf[i])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.

## ◆ fpsub_c() [3/4]

v4cfloat fpsub_c | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Subtract for single precision complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = acc[i] - conj(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpsub_c() [4/4]

v4cfloat fpsub_c | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs )

Subtract for single precision complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = acc[i] - conj(xbuf[xstart + xoffs[i]])

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | Input buffer.
  xstart | Starting offset for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X. Highest (4th) bit in each lane must be 0. Range per lane : [0,7]

The offsets are referring to complex lanes (lane 0 corresponds to the first real and imaginary value).

Note
  When xoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.