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

Loading...
Searching...
No Matches
Functions
Float
Intrinsics » Vector Operations » MAC intrinsics » Multiplication » Advanced

## Overview

Advanced Float Vector Operations. This page contains the fully configurable fpmac_conf and some convenient wrappers to it. The lane selection scheme is explained after each intrinsic definition.

Some of this floating point operations can generate exceptions, for more information you can go here.

## Functions
v8float | fpabs_mul (v16float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and take absolute value for single precision real times real floating point vectors.
v8float | fpabs_mul (v16float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and take absolute value for single precision real times real floating point vectors.
v8float | fpabs_mul (v32float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and take absolute value for single precision real times real floating point vectors.
v8float | fpabs_mul (v32float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and take absolute value for single precision real times real floating point vectors.
v8float | fpabs_mul (v8float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and take absolute value for single precision real times real floating point vectors.
v8float | fpabs_mul (v8float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and take absolute value for single precision real times real floating point vectors.
v8float | fpabs_mul (v8float xbuf, v8float zbuf)
| Multiply and take absolute value for single precision real times real floating point vectors.
v4cfloat | fpmac (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex times complex floating point vectors.
v4cfloat | fpmac (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex times complex floating point vectors.
v4cfloat | fpmac (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex times real floating point vectors.
v4cfloat | fpmac (v4cfloat acc, v16float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision real times complex floating point vectors.
v4cfloat | fpmac (v4cfloat acc, v32float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision real times complex floating point vectors.
v4cfloat | fpmac (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex times complex floating point vectors.
v4cfloat | fpmac (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex times complex floating point vectors.
v4cfloat | fpmac (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex times real floating point vectors.
v4cfloat | fpmac (v4cfloat acc, v4cfloat xbuf, v4cfloat zbuf)
| Multiply and accumulate for single precision complex times complex floating point vectors.
v4cfloat | fpmac (v4cfloat acc, v4cfloat xbuf, v8float zbuf)
| Multiply and accumulate for single precision complex times real floating point vectors.
v4cfloat | fpmac (v4cfloat acc, v4float xbuf, v4cfloat zbuf)
| Multiply and accumulate for single precision real times complex floating point vectors.
v4cfloat | fpmac (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex times complex floating point vectors.
v4cfloat | fpmac (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex times complex floating point vectors.
v4cfloat | fpmac (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex times real floating point vectors.
v4cfloat | fpmac (v4cfloat acc, v8float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision real times complex floating point vectors.
v8float | fpmac (v8float acc, v16float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision real times real floating point vectors.
v8float | fpmac (v8float acc, v16float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision real times real floating point vectors.
v8float | fpmac (v8float acc, v32float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision real times real floating point vectors.
v8float | fpmac (v8float acc, v32float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision real times real floating point vectors.
v8float | fpmac (v8float acc, v8float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision real times real floating point vectors.
v8float | fpmac (v8float acc, v8float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision real times real floating point vectors.
v8float | fpmac (v8float acc, v8float xbuf, v8float zbuf)
| Multiply and accumulate for single precision real times real floating point vectors.
v8float | fpmac_abs (v8float acc, v16float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply, take absolute value and accumulate for single precision real times real floating point vectors.
v8float | fpmac_abs (v8float acc, v16float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply, take absolute value and accumulate for single precision real times real floating point vectors.
v8float | fpmac_abs (v8float acc, v32float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply, take absolute value and accumulate for single precision real times real floating point vectors.
v8float | fpmac_abs (v8float acc, v32float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply, take absolute value and accumulate for single precision real times real floating point vectors.
v8float | fpmac_abs (v8float acc, v8float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply, take absolute value and accumulate for single precision real times real floating point vectors.
v8float | fpmac_abs (v8float acc, v8float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply, take absolute value and accumulate for single precision real times real floating point vectors.
v8float | fpmac_abs (v8float acc, v8float xbuf, v8float zbuf)
| Multiply, take absolute value and accumulate for single precision real times real floating point vectors.
v4cfloat | fpmac_c (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex conjugate times real floating point vectors.
v4cfloat | fpmac_c (v4cfloat acc, v16float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision real times complex conjugate floating point vectors.
v4cfloat | fpmac_c (v4cfloat acc, v32float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision real times complex conjugate floating point vectors.
v4cfloat | fpmac_c (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex conjugate times real floating point vectors.
v4cfloat | fpmac_c (v4cfloat acc, v4cfloat xbuf, v8float zbuf)
| Multiply and accumulate for single precision complex conjugate times real floating point vectors.
v4cfloat | fpmac_c (v4cfloat acc, v4float xbuf, v4cfloat zbuf)
| Multiply and accumulate for single precision real times complex conjugate floating point vectors.
v4cfloat | fpmac_c (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex conjugate times real floating point vectors.
v4cfloat | fpmac_c (v4cfloat acc, v8float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision real times complex conjugate floating point vectors.
v4cfloat | fpmac_cc (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmac_cc (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmac_cc (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmac_cc (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmac_cc (v4cfloat acc, v4cfloat xbuf, v4cfloat zbuf)
| Multiply and accumulate for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmac_cc (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmac_cc (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmac_cn (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmac_cn (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmac_cn (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmac_cn (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmac_cn (v4cfloat acc, v4cfloat xbuf, v4cfloat zbuf)
| Multiply and accumulate for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmac_cn (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmac_cn (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v16float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v16float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v32float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v32float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v8float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_conf (v4cfloat acc, v8float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v8float | fpmac_conf (v8float acc, v16float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v8float | fpmac_conf (v8float acc, v16float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v8float | fpmac_conf (v8float acc, v16float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v8float | fpmac_conf (v8float acc, v16float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v8float | fpmac_conf (v8float acc, v32float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v8float | fpmac_conf (v8float acc, v32float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v8float | fpmac_conf (v8float acc, v32float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v8float | fpmac_conf (v8float acc, v32float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v8float | fpmac_conf (v8float acc, v8float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v8float | fpmac_conf (v8float acc, v8float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v8float | fpmac_conf (v8float acc, v8float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v8float | fpmac_conf (v8float acc, v8float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply and accumulate for single precision floating point vectors.
v4cfloat | fpmac_nc (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmac_nc (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmac_nc (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmac_nc (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmac_nc (v4cfloat acc, v4cfloat xbuf, v4cfloat zbuf)
| Multiply and accumulate for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmac_nc (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmac_nc (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and accumulate for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmsc (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex times complex floating point vectors.
v4cfloat | fpmsc (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex times complex floating point vectors.
v4cfloat | fpmsc (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex times real floating point vectors.
v4cfloat | fpmsc (v4cfloat acc, v16float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision real times complex floating point vectors.
v4cfloat | fpmsc (v4cfloat acc, v32float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision real times complex floating point vectors.
v4cfloat | fpmsc (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex times complex floating point vectors.
v4cfloat | fpmsc (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex times complex floating point vectors.
v4cfloat | fpmsc (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex times real floating point vectors.
v4cfloat | fpmsc (v4cfloat acc, v4cfloat xbuf, v4cfloat zbuf)
| Multiply and subtract for single precision complex times complex floating point vectors.
v4cfloat | fpmsc (v4cfloat acc, v4cfloat xbuf, v8float zbuf)
| Multiply and subtract for single precision complex times real floating point vectors.
v4cfloat | fpmsc (v4cfloat acc, v4float xbuf, v4cfloat zbuf)
| Multiply and subtract for single precision real times complex floating point vectors.
v4cfloat | fpmsc (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex times complex floating point vectors.
v4cfloat | fpmsc (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex times complex floating point vectors.
v4cfloat | fpmsc (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex times real floating point vectors.
v4cfloat | fpmsc (v4cfloat acc, v8float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision real times complex floating point vectors.
v8float | fpmsc (v8float acc, v16float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision real times real floating point vectors.
v8float | fpmsc (v8float acc, v16float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision real times real floating point vectors.
v8float | fpmsc (v8float acc, v32float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision real times real floating point vectors.
v8float | fpmsc (v8float acc, v32float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision real times real floating point vectors.
v8float | fpmsc (v8float acc, v8float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision real times real floating point vectors.
v8float | fpmsc (v8float acc, v8float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision real times real floating point vectors.
v8float | fpmsc (v8float acc, v8float xbuf, v8float zbuf)
| Multiply and subtract for single precision real times real floating point vectors.
v8float | fpmsc_abs (v8float acc, v16float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply, take absolute value and subtract for single precision real times real floating point vectors.
v8float | fpmsc_abs (v8float acc, v16float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply, take absolute value and subtract for single precision real times real floating point vectors.
v8float | fpmsc_abs (v8float acc, v32float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply, take absolute value and subtract for single precision real times real floating point vectors.
v8float | fpmsc_abs (v8float acc, v32float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply, take absolute value and subtract for single precision real times real floating point vectors.
v8float | fpmsc_abs (v8float acc, v8float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply, take absolute value and subtract for single precision real times real floating point vectors.
v8float | fpmsc_abs (v8float acc, v8float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply, take absolute value and subtract for single precision real times real floating point vectors.
v8float | fpmsc_abs (v8float acc, v8float xbuf, v8float zbuf)
| Multiply, take absolute value and subtract for single precision real times real floating point vectors.
v4cfloat | fpmsc_c (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex conjugate times real floating point vectors.
v4cfloat | fpmsc_c (v4cfloat acc, v16float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision real times complex conjugate floating point vectors.
v4cfloat | fpmsc_c (v4cfloat acc, v32float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision real times complex conjugate floating point vectors.
v4cfloat | fpmsc_c (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex conjugate times real floating point vectors.
v4cfloat | fpmsc_c (v4cfloat acc, v4cfloat xbuf, v8float zbuf)
| Multiply and subtract for single precision complex conjugate times real floating point vectors.
v4cfloat | fpmsc_c (v4cfloat acc, v4float xbuf, v4cfloat zbuf)
| Multiply and subtract for single precision real times complex conjugate floating point vectors.
v4cfloat | fpmsc_c (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex conjugate times real floating point vectors.
v4cfloat | fpmsc_c (v4cfloat acc, v8float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision real times complex conjugate floating point vectors.
v4cfloat | fpmsc_cc (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmsc_cc (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmsc_cc (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmsc_cc (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmsc_cc (v4cfloat acc, v4cfloat xbuf, v4cfloat zbuf)
| Multiply and subtract for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmsc_cc (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmsc_cc (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmsc_cn (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmsc_cn (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmsc_cn (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmsc_cn (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmsc_cn (v4cfloat acc, v4cfloat xbuf, v4cfloat zbuf)
| Multiply and subtract for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmsc_cn (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmsc_cn (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmsc_nc (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmsc_nc (v4cfloat acc, v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmsc_nc (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmsc_nc (v4cfloat acc, v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmsc_nc (v4cfloat acc, v4cfloat xbuf, v4cfloat zbuf)
| Multiply and subtract for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmsc_nc (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmsc_nc (v4cfloat acc, v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and subtract for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmul (v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply for single precision complex times complex floating point vectors.
v4cfloat | fpmul (v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex times complex floating point vectors.
v4cfloat | fpmul (v16cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex times real floating point vectors.
v8float | fpmul (v16float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply for single precision real times real floating point vectors.
v4cfloat | fpmul (v16float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision real times complex floating point vectors.
v8float | fpmul (v16float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision real times real floating point vectors.
v8float | fpmul (v32float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply for single precision real times real floating point vectors.
v4cfloat | fpmul (v32float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision real times complex floating point vectors.
v8float | fpmul (v32float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision real times real floating point vectors.
v4cfloat | fpmul (v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply for single precision complex times complex floating point vectors.
v4cfloat | fpmul (v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex times complex floating point vectors.
v4cfloat | fpmul (v4cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex times real floating point vectors.
v4cfloat | fpmul (v4cfloat xbuf, v4cfloat zbuf)
| Multiply for single precision complex times complex floating point vectors.
v4cfloat | fpmul (v4cfloat xbuf, v8float zbuf)
| Multiply for single precision complex times real floating point vectors.
v4cfloat | fpmul (v4float xbuf, v4cfloat zbuf)
| Multiply for single precision real times complex floating point vectors.
v4cfloat | fpmul (v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply for single precision complex times complex floating point vectors.
v4cfloat | fpmul (v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex times complex floating point vectors.
v4cfloat | fpmul (v8cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex times real floating point vectors.
v8float | fpmul (v8float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply for single precision real times real floating point vectors.
v4cfloat | fpmul (v8float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision real times complex floating point vectors.
v8float | fpmul (v8float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision real times real floating point vectors.
v8float | fpmul (v8float xbuf, v8float zbuf)
| Multiply for single precision real times real floating point vectors.
v4cfloat | fpmul_c (v16cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex conjugate times real floating point vectors.
v4cfloat | fpmul_c (v16float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision real times complex conjugate floating point vectors.
v4cfloat | fpmul_c (v32float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision real times complex conjugate floating point vectors.
v4cfloat | fpmul_c (v4cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex conjugate times real floating point vectors.
v4cfloat | fpmul_c (v4cfloat xbuf, v8float zbuf)
| Multiply for single precision complex conjugate times real floating point vectors.
v4cfloat | fpmul_c (v4float xbuf, v4cfloat zbuf)
| Multiply for single precision real times complex conjugate floating point vectors.
v4cfloat | fpmul_c (v8cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex conjugate times real floating point vectors.
v4cfloat | fpmul_c (v8float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision real times complex conjugate floating point vectors.
v4cfloat | fpmul_cc (v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmul_cc (v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmul_cc (v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmul_cc (v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmul_cc (v4cfloat xbuf, v4cfloat zbuf)
| Multiply for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmul_cc (v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmul_cc (v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpmul_cn (v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmul_cn (v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmul_cn (v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmul_cn (v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmul_cn (v4cfloat xbuf, v4cfloat zbuf)
| Multiply for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmul_cn (v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmul_cn (v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpmul_conf (v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v16cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v16cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v8float | fpmul_conf (v16float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v8float | fpmul_conf (v16float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v16float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v16float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v8float | fpmul_conf (v16float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v8float | fpmul_conf (v16float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v8float | fpmul_conf (v32float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v8float | fpmul_conf (v32float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v32float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v32float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v8float | fpmul_conf (v32float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v8float | fpmul_conf (v32float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v4cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v4cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v8cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v8cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v8float | fpmul_conf (v8float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v8float | fpmul_conf (v8float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v8float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_conf (v8float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v8float | fpmul_conf (v8float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode)
| Fully configurable multiply for single precision floating point vectors.
v8float | fpmul_conf (v8float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs, bool ones, bool abs, unsigned int addmode, unsigned int addmask, unsigned int cmpmode, unsigned int &cmp)
| Fully configurable multiply for single precision floating point vectors.
v4cfloat | fpmul_nc (v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmul_nc (v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmul_nc (v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmul_nc (v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmul_nc (v4cfloat xbuf, v4cfloat zbuf)
| Multiply for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmul_nc (v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpmul_nc (v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply for single precision complex times complex conjugate floating point vectors.
v8float | fpneg_abs_mul (v16float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply, take absolute value and negate for single precision real times real floating point vectors.
v8float | fpneg_abs_mul (v16float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply, take absolute value and negate for single precision real times real floating point vectors.
v8float | fpneg_abs_mul (v32float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply, take absolute value and negate for single precision real times real floating point vectors.
v8float | fpneg_abs_mul (v32float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply, take absolute value and negate for single precision real times real floating point vectors.
v8float | fpneg_abs_mul (v8float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply, take absolute value and negate for single precision real times real floating point vectors.
v8float | fpneg_abs_mul (v8float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply, take absolute value and negate for single precision real times real floating point vectors.
v8float | fpneg_abs_mul (v8float xbuf, v8float zbuf)
| Multiply, take absolute value and negate for single precision real times real floating point vectors.
v4cfloat | fpneg_mul (v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex times complex floating point vectors.
v4cfloat | fpneg_mul (v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex times complex floating point vectors.
v4cfloat | fpneg_mul (v16cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex times real floating point vectors.
v8float | fpneg_mul (v16float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and negate for single precision real times real floating point vectors.
v4cfloat | fpneg_mul (v16float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision real times complex floating point vectors.
v8float | fpneg_mul (v16float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision real times real floating point vectors.
v8float | fpneg_mul (v32float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and negate for single precision real times real floating point vectors.
v4cfloat | fpneg_mul (v32float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision real times complex floating point vectors.
v8float | fpneg_mul (v32float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision real times real floating point vectors.
v4cfloat | fpneg_mul (v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex times complex floating point vectors.
v4cfloat | fpneg_mul (v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex times complex floating point vectors.
v4cfloat | fpneg_mul (v4cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex times real floating point vectors.
v4cfloat | fpneg_mul (v4cfloat xbuf, v4cfloat zbuf)
| Multiply and negate for single precision complex times complex floating point vectors.
v4cfloat | fpneg_mul (v4cfloat xbuf, v8float zbuf)
| Multiply and negate for single precision complex times real floating point vectors.
v4cfloat | fpneg_mul (v4float xbuf, v4cfloat zbuf)
| Multiply and negate for single precision real times complex floating point vectors.
v4cfloat | fpneg_mul (v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex times complex floating point vectors.
v4cfloat | fpneg_mul (v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex times complex floating point vectors.
v4cfloat | fpneg_mul (v8cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex times real floating point vectors.
v8float | fpneg_mul (v8float xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and negate for single precision real times real floating point vectors.
v4cfloat | fpneg_mul (v8float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision real times complex floating point vectors.
v8float | fpneg_mul (v8float xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision real times real floating point vectors.
v8float | fpneg_mul (v8float xbuf, v8float zbuf)
| Multiply and negate for single precision real times real floating point vectors.
v4cfloat | fpneg_mul_c (v16cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex conjugate times real floating point vectors.
v4cfloat | fpneg_mul_c (v16float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision real times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_c (v32float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision real times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_c (v4cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex conjugate times real floating point vectors.
v4cfloat | fpneg_mul_c (v4cfloat xbuf, v8float zbuf)
| Multiply and negate for single precision complex conjugate times real floating point vectors.
v4cfloat | fpneg_mul_c (v4float xbuf, v4cfloat zbuf)
| Multiply and negate for single precision real times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_c (v8cfloat xbuf, int xstart, unsigned int xoffs, v8float zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex conjugate times real floating point vectors.
v4cfloat | fpneg_mul_c (v8float xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision real times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_cc (v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_cc (v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_cc (v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_cc (v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_cc (v4cfloat xbuf, v4cfloat zbuf)
| Multiply and negate for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_cc (v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_cc (v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex conjugate times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_cn (v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpneg_mul_cn (v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpneg_mul_cn (v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpneg_mul_cn (v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpneg_mul_cn (v4cfloat xbuf, v4cfloat zbuf)
| Multiply and negate for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpneg_mul_cn (v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpneg_mul_cn (v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex conjugate times complex floating point vectors.
v4cfloat | fpneg_mul_nc (v16cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_nc (v16cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_nc (v4cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_nc (v4cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_nc (v4cfloat xbuf, v4cfloat zbuf)
| Multiply and negate for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_nc (v8cfloat xbuf, int xstart, unsigned int xoffs, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex times complex conjugate floating point vectors.
v4cfloat | fpneg_mul_nc (v8cfloat xbuf, int xstart, unsigned int xoffs, v4cfloat zbuf, int zstart, unsigned int zoffs)
| Multiply and negate for single precision complex times complex conjugate floating point vectors.

## Function Documentation

## ◆ fpabs_mul() [1/7]

v8float fpabs_mul | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and take absolute value for single precision real times real floating point vectors.

for (i = 0 ; i < 8 ; i++)
ret[i] = abs(xbuf[xstart + xoffs[i]] * xbuf[zstart + zoffs[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 | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpabs_mul() [2/7]

v8float fpabs_mul | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and take absolute value for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpabs_mul() [3/7]

v8float fpabs_mul | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and take absolute value for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpabs_mul() [4/7]

v8float fpabs_mul | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and take absolute value for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpabs_mul() [5/7]

v8float fpabs_mul | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and take absolute value for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpabs_mul() [6/7]

v8float fpabs_mul | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and take absolute value for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpabs_mul() [7/7]

v8float fpabs_mul | ( | v8float | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply and take absolute value for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmac() [1/22]

v4cfloat fpmac | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac() [2/22]

v4cfloat fpmac | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac() [3/22]

v4cfloat fpmac | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmac() [4/22]

v4cfloat fpmac | ( | v4cfloat | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision real times complex floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac() [5/22]

v4cfloat fpmac | ( | v4cfloat | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision real times complex floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac() [6/22]

v4cfloat fpmac | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac() [7/22]

v4cfloat fpmac | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac() [8/22]

v4cfloat fpmac | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmac() [9/22]

v4cfloat fpmac | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and accumulate for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmac() [10/22]

v4cfloat fpmac | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply and accumulate for single precision complex times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmac() [11/22]

v4cfloat fpmac | ( | v4cfloat | acc,
|  | v4float | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and accumulate for single precision real times complex floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmac() [12/22]

v4cfloat fpmac | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac() [13/22]

v4cfloat fpmac | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac() [14/22]

v4cfloat fpmac | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmac() [15/22]

v4cfloat fpmac | ( | v4cfloat | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision real times complex floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac() [16/22]

v8float fpmac | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpmac() [17/22]

v8float fpmac | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmac() [18/22]

v8float fpmac | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpmac() [19/22]

v8float fpmac | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmac() [20/22]

v8float fpmac | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpmac() [21/22]

v8float fpmac | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmac() [22/22]

v8float fpmac | ( | v8float | acc,
|  | v8float | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply and accumulate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmac_abs() [1/7]

v8float fpmac_abs | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and accumulate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpmac_abs() [2/7]

v8float fpmac_abs | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and accumulate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmac_abs() [3/7]

v8float fpmac_abs | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and accumulate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpmac_abs() [4/7]

v8float fpmac_abs | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and accumulate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmac_abs() [5/7]

v8float fpmac_abs | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and accumulate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpmac_abs() [6/7]

v8float fpmac_abs | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and accumulate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmac_abs() [7/7]

v8float fpmac_abs | ( | v8float | acc,
|  | v8float | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply, take absolute value and accumulate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmac_c() [1/8]

v4cfloat fpmac_c | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex conjugate times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmac_c() [2/8]

v4cfloat fpmac_c | ( | v4cfloat | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision real times complex conjugate floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_c() [3/8]

v4cfloat fpmac_c | ( | v4cfloat | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision real times complex conjugate floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_c() [4/8]

v4cfloat fpmac_c | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex conjugate times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmac_c() [5/8]

v4cfloat fpmac_c | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply and accumulate for single precision complex conjugate times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmac_c() [6/8]

v4cfloat fpmac_c | ( | v4cfloat | acc,
|  | v4float | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and accumulate for single precision real times complex conjugate floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmac_c() [7/8]

v4cfloat fpmac_c | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex conjugate times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmac_c() [8/8]

v4cfloat fpmac_c | ( | v4cfloat | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision real times complex conjugate floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_cc() [1/7]

v4cfloat fpmac_cc | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_cc() [2/7]

v4cfloat fpmac_cc | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_cc() [3/7]

v4cfloat fpmac_cc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_cc() [4/7]

v4cfloat fpmac_cc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_cc() [5/7]

v4cfloat fpmac_cc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and accumulate for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmac_cc() [6/7]

v4cfloat fpmac_cc | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_cc() [7/7]

v4cfloat fpmac_cc | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_cn() [1/7]

v4cfloat fpmac_cn | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_cn() [2/7]

v4cfloat fpmac_cn | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_cn() [3/7]

v4cfloat fpmac_cn | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_cn() [4/7]

v4cfloat fpmac_cn | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_cn() [5/7]

v4cfloat fpmac_cn | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and accumulate for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmac_cn() [6/7]

v4cfloat fpmac_cn | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_cn() [7/7]

v4cfloat fpmac_cn | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_conf() [1/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]
cmp
return cmp
Definition me_vfloat.h:5105

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [2/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [3/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [4/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [5/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [6/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [7/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [8/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [9/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [10/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [11/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [12/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [13/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [14/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [15/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [16/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [17/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [18/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [19/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [20/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [21/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [22/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [23/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [24/36]

v4cfloat fpmac_conf | ( | v4cfloat | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [25/36]

v8float fpmac_conf | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [26/36]

v8float fpmac_conf | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [27/36]

v8float fpmac_conf | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [28/36]

v8float fpmac_conf | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [29/36]

v8float fpmac_conf | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [30/36]

v8float fpmac_conf | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [31/36]

v8float fpmac_conf | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [32/36]

v8float fpmac_conf | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [33/36]

v8float fpmac_conf | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [34/36]

v8float fpmac_conf | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_conf() [35/36]

v8float fpmac_conf | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmac_conf() [36/36]

v8float fpmac_conf | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply and accumulate for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = acc[i] + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmac_nc() [1/7]

v4cfloat fpmac_nc | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_nc() [2/7]

v4cfloat fpmac_nc | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_nc() [3/7]

v4cfloat fpmac_nc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_nc() [4/7]

v4cfloat fpmac_nc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_nc() [5/7]

v4cfloat fpmac_nc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and accumulate for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmac_nc() [6/7]

v4cfloat fpmac_nc | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmac_nc() [7/7]

v4cfloat fpmac_nc | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and accumulate for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc() [1/22]

v4cfloat fpmsc | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc() [2/22]

v4cfloat fpmsc | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc() [3/22]

v4cfloat fpmsc | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmsc() [4/22]

v4cfloat fpmsc | ( | v4cfloat | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision real times complex floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc() [5/22]

v4cfloat fpmsc | ( | v4cfloat | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision real times complex floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc() [6/22]

v4cfloat fpmsc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc() [7/22]

v4cfloat fpmsc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc() [8/22]

v4cfloat fpmsc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmsc() [9/22]

v4cfloat fpmsc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and subtract for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmsc() [10/22]

v4cfloat fpmsc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply and subtract for single precision complex times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmsc() [11/22]

v4cfloat fpmsc | ( | v4cfloat | acc,
|  | v4float | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and subtract for single precision real times complex floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmsc() [12/22]

v4cfloat fpmsc | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc() [13/22]

v4cfloat fpmsc | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc() [14/22]

v4cfloat fpmsc | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmsc() [15/22]

v4cfloat fpmsc | ( | v4cfloat | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision real times complex floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc() [16/22]

v8float fpmsc | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpmsc() [17/22]

v8float fpmsc | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmsc() [18/22]

v8float fpmsc | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpmsc() [19/22]

v8float fpmsc | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmsc() [20/22]

v8float fpmsc | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpmsc() [21/22]

v8float fpmsc | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmsc() [22/22]

v8float fpmsc | ( | v8float | acc,
|  | v8float | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply and subtract for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmsc_abs() [1/7]

v8float fpmsc_abs | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and subtract for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpmsc_abs() [2/7]

v8float fpmsc_abs | ( | v8float | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and subtract for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmsc_abs() [3/7]

v8float fpmsc_abs | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and subtract for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpmsc_abs() [4/7]

v8float fpmsc_abs | ( | v8float | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and subtract for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmsc_abs() [5/7]

v8float fpmsc_abs | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and subtract for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpmsc_abs() [6/7]

v8float fpmsc_abs | ( | v8float | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and subtract for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmsc_abs() [7/7]

v8float fpmsc_abs | ( | v8float | acc,
|  | v8float | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply, take absolute value and subtract for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmsc_c() [1/8]

v4cfloat fpmsc_c | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex conjugate times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmsc_c() [2/8]

v4cfloat fpmsc_c | ( | v4cfloat | acc,
|  | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision real times complex conjugate floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_c() [3/8]

v4cfloat fpmsc_c | ( | v4cfloat | acc,
|  | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision real times complex conjugate floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_c() [4/8]

v4cfloat fpmsc_c | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex conjugate times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmsc_c() [5/8]

v4cfloat fpmsc_c | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply and subtract for single precision complex conjugate times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmsc_c() [6/8]

v4cfloat fpmsc_c | ( | v4cfloat | acc,
|  | v4float | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and subtract for single precision real times complex conjugate floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmsc_c() [7/8]

v4cfloat fpmsc_c | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex conjugate times real floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmsc_c() [8/8]

v4cfloat fpmsc_c | ( | v4cfloat | acc,
|  | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision real times complex conjugate floating point vectors.

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

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_cc() [1/7]

v4cfloat fpmsc_cc | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_cc() [2/7]

v4cfloat fpmsc_cc | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_cc() [3/7]

v4cfloat fpmsc_cc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_cc() [4/7]

v4cfloat fpmsc_cc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_cc() [5/7]

v4cfloat fpmsc_cc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and subtract for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmsc_cc() [6/7]

v4cfloat fpmsc_cc | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_cc() [7/7]

v4cfloat fpmsc_cc | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_cn() [1/7]

v4cfloat fpmsc_cn | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_cn() [2/7]

v4cfloat fpmsc_cn | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_cn() [3/7]

v4cfloat fpmsc_cn | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_cn() [4/7]

v4cfloat fpmsc_cn | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_cn() [5/7]

v4cfloat fpmsc_cn | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and subtract for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmsc_cn() [6/7]

v4cfloat fpmsc_cn | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_cn() [7/7]

v4cfloat fpmsc_cn | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_nc() [1/7]

v4cfloat fpmsc_nc | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_nc() [2/7]

v4cfloat fpmsc_nc | ( | v4cfloat | acc,
|  | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_nc() [3/7]

v4cfloat fpmsc_nc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_nc() [4/7]

v4cfloat fpmsc_nc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_nc() [5/7]

v4cfloat fpmsc_nc | ( | v4cfloat | acc,
|  | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and subtract for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmsc_nc() [6/7]

v4cfloat fpmsc_nc | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmsc_nc() [7/7]

v4cfloat fpmsc_nc | ( | v4cfloat | acc,
|  | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and subtract for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  acc | Incoming accumulation vector.
  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul() [1/22]

v4cfloat fpmul | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul() [2/22]

v4cfloat fpmul | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex times complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = xbuf[xstart + xoffs[i]] * zbuf[zstart + zoffs[i]]

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul() [3/22]

v4cfloat fpmul | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex times real floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = xbuf[xstart + xoffs[i]] * zbuf[zstart + zoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmul() [4/22]

v8float fpmul | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpmul() [5/22]

v4cfloat fpmul | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision real times complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = xbuf[xstart + xoffs[i]] * zbuf[zstart + zoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul() [6/22]

v8float fpmul | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision real times real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = xbuf[xstart + xoffs[i]] * zbuf[zstart + zoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmul() [7/22]

v8float fpmul | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpmul() [8/22]

v4cfloat fpmul | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision real times complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = xbuf[xstart + xoffs[i]] * zbuf[zstart + zoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul() [9/22]

v8float fpmul | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision real times real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = xbuf[xstart + xoffs[i]] * zbuf[zstart + zoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmul() [10/22]

v4cfloat fpmul | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul() [11/22]

v4cfloat fpmul | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex times complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = xbuf[xstart + xoffs[i]] * zbuf[zstart + zoffs[i]]

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul() [12/22]

v4cfloat fpmul | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex times real floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = xbuf[xstart + xoffs[i]] * zbuf[zstart + zoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmul() [13/22]

v4cfloat fpmul | ( | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmul() [14/22]

v4cfloat fpmul | ( | v4cfloat | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply for single precision complex times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmul() [15/22]

v4cfloat fpmul | ( | v4float | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply for single precision real times complex floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmul() [16/22]

v4cfloat fpmul | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul() [17/22]

v4cfloat fpmul | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex times complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = xbuf[xstart + xoffs[i]] * zbuf[zstart + zoffs[i]]

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul() [18/22]

v4cfloat fpmul | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex times real floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = xbuf[xstart + xoffs[i]] * zbuf[zstart + zoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmul() [19/22]

v8float fpmul | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpmul() [20/22]

v4cfloat fpmul | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision real times complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = xbuf[xstart + xoffs[i]] * zbuf[zstart + zoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul() [21/22]

v8float fpmul | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision real times real floating point vectors.

for (i = 0; i < 8; i++)
ret[i] = xbuf[xstart + xoffs[i]] * zbuf[zstart + zoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmul() [22/22]

v8float fpmul | ( | v8float | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmul_c() [1/8]

v4cfloat fpmul_c | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex conjugate times real floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = conj(xbuf[xstart + xoffs[i]]) * zbuf[zstart + zoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmul_c() [2/8]

v4cfloat fpmul_c | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision real times complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = xbuf[xstart + xoffs[i]] * conj(zbuf[zstart + zoffs[i]])

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_c() [3/8]

v4cfloat fpmul_c | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision real times complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = xbuf[xstart + xoffs[i]] * conj(zbuf[zstart + zoffs[i]])

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_c() [4/8]

v4cfloat fpmul_c | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex conjugate times real floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = conj(xbuf[xstart + xoffs[i]]) * zbuf[zstart + zoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmul_c() [5/8]

v4cfloat fpmul_c | ( | v4cfloat | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply for single precision complex conjugate times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmul_c() [6/8]

v4cfloat fpmul_c | ( | v4float | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply for single precision real times complex conjugate floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmul_c() [7/8]

v4cfloat fpmul_c | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex conjugate times real floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = conj(xbuf[xstart + xoffs[i]]) * zbuf[zstart + zoffs[i]]

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpmul_c() [8/8]

v4cfloat fpmul_c | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision real times complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = xbuf[xstart + xoffs[i]] * conj(zbuf[zstart + zoffs[i]])

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_cc() [1/7]

v4cfloat fpmul_cc | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_cc() [2/7]

v4cfloat fpmul_cc | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex conjugate times complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = conj(xbuf[xstart + xoffs[i]]) * conj(zbuf[zstart + zoffs[i]])

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_cc() [3/7]

v4cfloat fpmul_cc | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_cc() [4/7]

v4cfloat fpmul_cc | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex conjugate times complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = conj(xbuf[xstart + xoffs[i]]) * conj(zbuf[zstart + zoffs[i]])

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_cc() [5/7]

v4cfloat fpmul_cc | ( | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmul_cc() [6/7]

v4cfloat fpmul_cc | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_cc() [7/7]

v4cfloat fpmul_cc | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex conjugate times complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = conj(xbuf[xstart + xoffs[i]]) * conj(zbuf[zstart + zoffs[i]])

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_cn() [1/7]

v4cfloat fpmul_cn | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_cn() [2/7]

v4cfloat fpmul_cn | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex conjugate times complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = conj(xbuf[xstart + xoffs[i]]) * zbuf[zstart + zoffs[i]]

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_cn() [3/7]

v4cfloat fpmul_cn | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_cn() [4/7]

v4cfloat fpmul_cn | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex conjugate times complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = conj(xbuf[xstart + xoffs[i]]) * zbuf[zstart + zoffs[i]]

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_cn() [5/7]

v4cfloat fpmul_cn | ( | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmul_cn() [6/7]

v4cfloat fpmul_cn | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_cn() [7/7]

v4cfloat fpmul_cn | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex conjugate times complex floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = conj(xbuf[xstart + xoffs[i]]) * zbuf[zstart + zoffs[i]]

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_conf() [1/36]

v4cfloat fpmul_conf | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [2/36]

v4cfloat fpmul_conf | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [3/36]

v4cfloat fpmul_conf | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [4/36]

v4cfloat fpmul_conf | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [5/36]

v4cfloat fpmul_conf | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [6/36]

v4cfloat fpmul_conf | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [7/36]

v8float fpmul_conf | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [8/36]

v8float fpmul_conf | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [9/36]

v4cfloat fpmul_conf | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [10/36]

v4cfloat fpmul_conf | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [11/36]

v8float fpmul_conf | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [12/36]

v8float fpmul_conf | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [13/36]

v8float fpmul_conf | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [14/36]

v8float fpmul_conf | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [15/36]

v4cfloat fpmul_conf | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [16/36]

v4cfloat fpmul_conf | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [17/36]

v8float fpmul_conf | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [18/36]

v8float fpmul_conf | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [19/36]

v4cfloat fpmul_conf | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [20/36]

v4cfloat fpmul_conf | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [21/36]

v4cfloat fpmul_conf | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [22/36]

v4cfloat fpmul_conf | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [23/36]

v4cfloat fpmul_conf | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [24/36]

v4cfloat fpmul_conf | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [25/36]

v4cfloat fpmul_conf | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [26/36]

v4cfloat fpmul_conf | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [27/36]

v4cfloat fpmul_conf | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [28/36]

v4cfloat fpmul_conf | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [29/36]

v4cfloat fpmul_conf | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [30/36]

v4cfloat fpmul_conf | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [31/36]

v8float fpmul_conf | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [32/36]

v8float fpmul_conf | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : xbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for all lanes of second multiplicant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [33/36]

v4cfloat fpmul_conf | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [34/36]

v4cfloat fpmul_conf | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_conf() [35/36]

v8float fpmul_conf | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.

## ◆ fpmul_conf() [36/36]

v8float fpmul_conf | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs,
|  | bool | ones,
|  | bool | abs,
|  | unsigned int | addmode,
|  | unsigned int | addmask,
|  | unsigned int | cmpmode,
|  | unsigned int & | cmp
| ) |  |

Fully configurable multiply for single precision floating point vectors.

The output can be considered to always have 8 lanes beause each real and imaginary part of the complex float is handled as a separate lane.

if (addmode == fpadd_add ) neg = addmask ^ 0x00;
if (addmode == fpadd_sub ) neg = addmask ^ 0xFF;
if (addmode == fpadd_mixadd) neg = addmask ^ 0xAA;
if (addmode == fpadd_mixsub) neg = addmask ^ 0x55;
for (i = 0; i < 8; i++)
m[i] = xbuf[xstart + xoffs[i]] * (ones ? 1.0 : zbuf[zstart + zoffs[i]])
n[i] = (-1)^neg[i] * (abs ? |m[i]| : m[i])
o[i] = 0.0 + n[i]
if cmpmode == fpcmp_nrm :
cmp[i] = signbit(o[i])
ret[i] = o[i]
elif cmpmode == fpcmp_lt :
cmp[i] = signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]
elif cmpmode == fpcmp_ge :
cmp[i] = ~signbit(o[i])
ret[i] = cmp[i] ? -n[i] : acc[i]

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of second multiplicant. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant.
  ones | If true second multiplicant is replaced with 1.0.
  abs | If true the absolute value is taken before accumulation.
  addmode | Select one of fpadd_add, fpadd_sub, fpadd_mixadd or fpadd_mixsub. This must be a compile time constant.
  addmask | 8 x 1 LSB bits: Corresponding lane is negated if bit is set (depending on addmode).
  cmpmode | Use "fpcmp_lt" to select the minimum between accumulation and multiplication result per lane, "fpcmp_ge" for the maximum and "fpcmp_nrm" for the usual sum.
  cmp | 8 x 1 LSB bits: When using fpcmp_ge or fpcmp_lt in "cmpmode", it sets a bit if accumulator was chosen (per lane).

## ◆ fpmul_nc() [1/7]

v4cfloat fpmul_nc | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_nc() [2/7]

v4cfloat fpmul_nc | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex times complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = xbuf[xstart + xoffs[i]] * conj(zbuf[zstart + zoffs[i]])

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_nc() [3/7]

v4cfloat fpmul_nc | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_nc() [4/7]

v4cfloat fpmul_nc | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex times complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = xbuf[xstart + xoffs[i]] * conj(zbuf[zstart + zoffs[i]])

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_nc() [5/7]

v4cfloat fpmul_nc | ( | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpmul_nc() [6/7]

v4cfloat fpmul_nc | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpmul_nc() [7/7]

v4cfloat fpmul_nc | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply for single precision complex times complex conjugate floating point vectors.

for (i = 0; i < 4; i++)
ret[i] = xbuf[xstart + xoffs[i]] * conj(zbuf[zstart + zoffs[i]])

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_abs_mul() [1/7]

v8float fpneg_abs_mul | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and negate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpneg_abs_mul() [2/7]

v8float fpneg_abs_mul | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and negate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpneg_abs_mul() [3/7]

v8float fpneg_abs_mul | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and negate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpneg_abs_mul() [4/7]

v8float fpneg_abs_mul | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and negate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpneg_abs_mul() [5/7]

v8float fpneg_abs_mul | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and negate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpneg_abs_mul() [6/7]

v8float fpneg_abs_mul | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply, take absolute value and negate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpneg_abs_mul() [7/7]

v8float fpneg_abs_mul | ( | v8float | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply, take absolute value and negate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpneg_mul() [1/22]

v4cfloat fpneg_mul | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul() [2/22]

v4cfloat fpneg_mul | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul() [3/22]

v4cfloat fpneg_mul | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpneg_mul() [4/22]

v8float fpneg_mul | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpneg_mul() [5/22]

v4cfloat fpneg_mul | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision real times complex floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul() [6/22]

v8float fpneg_mul | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpneg_mul() [7/22]

v8float fpneg_mul | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpneg_mul() [8/22]

v4cfloat fpneg_mul | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision real times complex floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul() [9/22]

v8float fpneg_mul | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpneg_mul() [10/22]

v4cfloat fpneg_mul | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul() [11/22]

v4cfloat fpneg_mul | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul() [12/22]

v4cfloat fpneg_mul | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpneg_mul() [13/22]

v4cfloat fpneg_mul | ( | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and negate for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpneg_mul() [14/22]

v4cfloat fpneg_mul | ( | v4cfloat | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply and negate for single precision complex times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpneg_mul() [15/22]

v4cfloat fpneg_mul | ( | v4float | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and negate for single precision real times complex floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpneg_mul() [16/22]

v4cfloat fpneg_mul | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul() [17/22]

v4cfloat fpneg_mul | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul() [18/22]

v4cfloat fpneg_mul | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpneg_mul() [19/22]

v8float fpneg_mul | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zstart | Starting offset for second multiplicant for all lanes of X.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for second multiplicant in X.

## ◆ fpneg_mul() [20/22]

v4cfloat fpneg_mul | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision real times complex floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul() [21/22]

v8float fpneg_mul | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 8 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 8 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpneg_mul() [22/22]

v8float fpneg_mul | ( | v8float | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply and negate for single precision real times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpneg_mul_c() [1/8]

v4cfloat fpneg_mul_c | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex conjugate times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpneg_mul_c() [2/8]

v4cfloat fpneg_mul_c | ( | v16float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision real times complex conjugate floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_c() [3/8]

v4cfloat fpneg_mul_c | ( | v32float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision real times complex conjugate floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_c() [4/8]

v4cfloat fpneg_mul_c | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex conjugate times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpneg_mul_c() [5/8]

v4cfloat fpneg_mul_c | ( | v4cfloat | xbuf,
|  | v8float | zbuf
| ) |  |

Multiply and negate for single precision complex conjugate times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpneg_mul_c() [6/8]

v4cfloat fpneg_mul_c | ( | v4float | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and negate for single precision real times complex conjugate floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpneg_mul_c() [7/8]

v4cfloat fpneg_mul_c | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v8float | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex conjugate times real floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant.
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z.

## ◆ fpneg_mul_c() [8/8]

v4cfloat fpneg_mul_c | ( | v8float | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision real times complex conjugate floating point vectors.

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

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  xstart | Starting offset for all lanes of X.
  xoffs | 4 x 4 bits: Additional lane-dependent offset for X.
  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_cc() [1/7]

v4cfloat fpneg_mul_cc | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_cc() [2/7]

v4cfloat fpneg_mul_cc | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_cc() [3/7]

v4cfloat fpneg_mul_cc | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_cc() [4/7]

v4cfloat fpneg_mul_cc | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_cc() [5/7]

v4cfloat fpneg_mul_cc | ( | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and negate for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpneg_mul_cc() [6/7]

v4cfloat fpneg_mul_cc | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_cc() [7/7]

v4cfloat fpneg_mul_cc | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex conjugate times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_cn() [1/7]

v4cfloat fpneg_mul_cn | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_cn() [2/7]

v4cfloat fpneg_mul_cn | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_cn() [3/7]

v4cfloat fpneg_mul_cn | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_cn() [4/7]

v4cfloat fpneg_mul_cn | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_cn() [5/7]

v4cfloat fpneg_mul_cn | ( | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and negate for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpneg_mul_cn() [6/7]

v4cfloat fpneg_mul_cn | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_cn() [7/7]

v4cfloat fpneg_mul_cn | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex conjugate times complex floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_nc() [1/7]

v4cfloat fpneg_mul_nc | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_nc() [2/7]

v4cfloat fpneg_mul_nc | ( | v16cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_nc() [3/7]

v4cfloat fpneg_mul_nc | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_nc() [4/7]

v4cfloat fpneg_mul_nc | ( | v4cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_nc() [5/7]

v4cfloat fpneg_mul_nc | ( | v4cfloat | xbuf,
|  | v4cfloat | zbuf
| ) |  |

Multiply and negate for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication input buffer.
  zbuf | Second multiplication input buffer.

## ◆ fpneg_mul_nc() [6/7]

v4cfloat fpneg_mul_nc | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zstart | Starting offset for second multiplicant for all lanes of X. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for second multiplicant in 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.

## ◆ fpneg_mul_nc() [7/7]

v4cfloat fpneg_mul_nc | ( | v8cfloat | xbuf,
|  | int | xstart,
|  | unsigned int | xoffs,
|  | v4cfloat | zbuf,
|  | int | zstart,
|  | unsigned int | zoffs
| ) |  |

Multiply and negate for single precision complex times complex conjugate floating point vectors.

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

Note
  This is a two-cycle intrinsic which will result in two microcode instructions to be scheduled. The same behavior can be achieved by calling the fully configurable multiply-accumulate intrinsic twice in order to add the two terms of the complex multiplication.

Returns
  Result vector.

Parameters

  xbuf | First multiplication 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.

Parameters

  zbuf | Second multiplication input buffer.
  zstart | Starting offset for all lanes of Z. This must be a compile time constant. The start value refers to complex lanes (lane 0 corresponds to the first real and imaginary value).
  zoffs | 4 x 4 bits: Additional lane-dependent offset for Z. 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 zoffs is a runtime parameter, it might be more efficient to use fpmac_conf and calculate the offsets manually.