SIMD Acceleration¶

Cross-platform SIMD vector operations and hardware acceleration.

A¶

function abs(const T1 &) Returns the absolute value of x.
function absmax(const T1 &, const T2 &) Returns the greater in magnitude of two values.
function absmin(const T1 &, const T2 &) Returns the smaller in magnitude of two values.
function add(const T &) Identity add (single argument).
function add(const T1 &, const T2 &, const Ts &...) Returns sum of all the arguments passed to a function.
function add(initialvalue<T>) Identity element for add (returns zero).
function addsub(const vec<T, N> &, const vec<T, N> &) Returns a vector with a+b in the low half and a-b in the high half.
function all(const mask<T, N> &) Returns true if all elements are true.
function special_scalar_constants<T>::allones() Returns a value with all bits set.
function special_scalar_constants<float>::allones() Returns a floating-point value with all bits set.
function special_scalar_constants<double>::allones() Returns a floating-point value with all bits set.
function special_scalar_constants<bit<T>>::allones() All bits set (true).
function allonesvector() Return a vector of the given type and size with all bits set to 1.
function allonesvector(vec_shape<T, N>) Return a vector matching the given shape with all bits set to 1.
function allonesvector(vec<T, N>) Return a vector matching the type of the given vector with all bits set to 1.
function special_scalar_constants<T>::allzeros() Returns a value with all bits cleared.
function special_scalar_constants<float>::allzeros() Returns positive zero, whose bits are all cleared.
function special_scalar_constants<double>::allzeros() Returns positive zero, whose bits are all cleared.
function special_scalar_constants<bit<T>>::allzeros() All bits cleared (false).
union vec<T, N>::(Anonymous union at simd/vec.hpp:831:5)
function any(const mask<T, N> &) Returns true if any element is true.
function apply(Fn &&) Generate a vector by calling a nullary function N times.
function apply(Fn &&, const T &, Args &&...) Apply a function to a scalar (pass-through overload).
function apply(Fn &&, const vec<T, N> &, Args &&...) Apply a scalar function element-wise to a vector.
function i24::as_int() Reconstructs the signed 32-bit value, sign-extending from bit 23.
function vec<T, N>::asmask() Reinterpret the bits as a mask of the same shape.
function vec<T, N>::asvec() Reinterpret a mask vector as a value vector (drops the bit wrapper).
function compound_type_traits<kfr::vec<T, N>>::at(const kfr::vec<T, N> &, size_t)
function compound_type_traits<std::complex<T>>::at(const std::complex<T> &, size_t) Returns the real ( index == 0) or imaginary ( index == 1) part of value.
enum constant cpu_t::avx
enum constant cpu_t::avx1
enum constant cpu_t::avx2
enum constant cpu_t::avx512

B¶

function portable_vec<T, N>::back()
function portable_vec<T, N>::back()
function vec<T, N>::back() Read the last element from a const lvalue vector.
function vec<T, N>::back() Read the last element from an rvalue vector.
function vec<T, N>::back() Access the last element of a non-const lvalue vector.
typedef stride_pointer<T, groupsize>::base_type
function bitcast(const From &) Reinterpret the bits of value as type To .
function bitcast(const vec<From, N> &) Reinterpret the bits of a vector as a vector of a different element type.
class bitmask<bits> Holds an unsigned integer wide enough to store bits bits.
constructor bitmask<bits>::bitmask<bits>(type) Construct from a value of the underlying type.
function bitness_const(const char *, const char *) Selects between 32-bit and 64-bit compile-time constants.
function bitness_const(const T &, const T &) Selects between 32-bit and 64-bit compile-time constants.
function bitpermute(const vec<T, N> &) Permute the elements of a vector according to a bit permutation.
function bitreverse(const vec<T, N> &) Reorders the elements of a vector by reversing the bits of their indices.
function bitreverse(u32) Reverses the lowest bits bits of the given unsigned integer.
function bitreverse(u32, size_t) Reverses the lowest bits bits of the given unsigned integer at runtime.
class bit<T> Boolean value stored as a mask of type T (all-ones for true, all-zeros for false).
constructor bit<T>::bit<T>() Default constructor leaving the value uninitialized.
constructor bit<T>::bit<T>(bool) Construct from a bool, storing all-ones or all-zeros.
function bit<T>::bit<T>(const bit<U> &) Convert a bit of another element type to this one.
constructor bit<T>::bit<T>(T)
function bitwiseand(const T1 &, const T2 &) Bitwise AND of x and y .
function bitwiseand(double, double)
function bitwiseand(float, float)
function bitwiseand(initialvalue<T>) Identity element for bitwiseand (returns all ones).
function bitwiseandnot(const T1 &, const T2 &) Bitwise AND-NOT of x and y .
function bitwiseandnot(double, double)
function bitwiseandnot(float, float)
function bitwiseandnot(initialvalue<T>) Identity element for bitwiseandnot (returns all ones).
function bitwisenot(const T1 &) Bitwise NOT of x .
function bitwisenot(double)
function bitwisenot(float)
function bitwiseor(const T1 &, const T2 &) Bitwise OR of x and y .
function bitwiseor(double, double)
function bitwiseor(float, float)
function bitwiseor(initialvalue<T>) Identity element for bitwiseor (returns zero).
function bitwisexor(const T1 &, const T2 &) Bitwise XOR (exclusive OR) of x and y .
function bitwisexor(double, double)
function bitwisexor(float, float)
function bitwisexor(initialvalue<T>) Identity element for bitwisexor (returns zero).
function blend(const vec<T, N> &, const vec<T, N> &, elements_t<Indices...>) Blends lanes from x and y according to a repeating selector pattern.
function block_process(size_t, csizes_t<widths...>, Fn &&) Processes a range using a sequence of decreasing block widths.
function broadcast(const Ts &...) Broadcasts a pack of scalar values into a vector of length Nout.
function broadcast(T) Broadcast a scalar to all N elements of a vector.
function broadcastto(const From &) Broadcast-cast a scalar to To (deep rebind).
function broadcastto(const vec<Tin, N> &) Broadcast-cast a vector to a different element type.
function broadcastto(const vec<Tin, N> &) Identity broadcast-cast for a vector (same element type).
function broadcastto(const vec<vec<Tin, N1>, N2> &) Broadcast-cast a nested vector to a different element type.
function broadcastto(const vec<vec<Tin, N1>, N2> &) Identity broadcast-cast for a nested vector (same element type).

C¶

typedef c32 Alias for complex<f32>
typedef c64 Alias for complex<f64>
variable c_degtorad Degrees to radians conversion factor (π / 180).
variable c_e The mathematical constant e (Euler's number), scaled by m/d.
variable c_epsilon The machine epsilon — the smallest value such that 1 + epsilon ≠ 1.
variable c_infinity Positive infinity representation.
variable c_log_10 The natural logarithm of 10 (ln(10)).
variable c_log_2 The natural logarithm of 2 (ln(2)).
variable c_mantissa_bits The number of mantissa bits for the given floating-point type.
variable c_mantissa_mask The bitmask for the mantissa of the floating-point representation.
variable c_neginfinity Negative infinity representation.
variable c_pi The mathematical constant π (pi), scaled by m/d.
variable c_qnan A quiet NaN (Not-a-Number) value.
variable c_radtodeg Radians to degrees conversion factor (180 / π).
variable c_recip_log_10 The reciprocal of the natural logarithm of 10 (1 / ln(10)).
variable c_recip_log_2 The reciprocal of the natural logarithm of 2 (1 / ln(2)).
variable c_recip_pi The reciprocal of π (1/π), scaled by m/d.
variable c_sqr_pi The square of π (pi²), scaled by m/d.
variable c_sqrt_2 The square root of 2 (√2), scaled by m/d.
variable caligned Instance of caligned_t.
typedef caligned_t Compile-time boolean tag selecting aligned access.
function cast(const From &) Cast a scalar value to To (deep rebind).
function cast(const vec<Tin, N> &) Cast a vector to a different element type.
function cast(const vec<Tin, N> &) Identity cast for a vector (same element type).
function cast(const vec<vec<Tin, N1>, N2> &) Cast a nested vector to a different element type.
function cast(const vec<vec<Tin, N1>, N2> &) Identity cast for a nested vector (same element type).
typedef cbase Alias for complex<fbase>
function ccomp(const vec<T, N> &) Composes a vector of N/2 complex values from a flattened N-element real vector.
function cconj(const T1 &) Returns the complex conjugate of the complex number x
variable ccpu Compile-time constant instance of ccpu_t .
typedef ccpu_t Compile-time wrapper around a cpu_t value.
function cdecom(const vec<complex<T>, N> &) Decomposes a vector of N complex values into a flattened 2N-element real vector.
function cdupimag(const vec<complex<T>, N> &) Returns vector of complex values with imaginary part duplicated
function cdupreal(const vec<complex<T>, N> &) Returns vector of complex values with real part duplicated
function ceil(const T1 &) Returns the smallest integer value not less than x.
typedef opencl_names::char16
typedef opencl_names::char2
typedef opencl_names::char3
typedef opencl_names::char4
typedef opencl_names::char8
function clamp(const T1 &, const T2 &) Returns the first argument clamped to a range [0, hi]
function clamp(const T1 &, const T2 &, const T3 &) Returns the first argument clamped to a range [lo, hi]
function cnegimag(const vec<complex<T>, N> &) Returns vector of complex values with imaginary part negated
function cnegreal(const vec<complex<T>, N> &) Returns vector of complex values with real part negated
function column(const vec<vec<T, N1>, N2> &) Extracts a single column from a vector-of-vectors.
function combine(const vec<T, N1> &, const vec<T, N2> &) Combines two vectors by selecting lanes from x or y based on index.
enum constant cpu_t::common
variable platform<cpu_t::common>::common_float_vector_size
variable platform<cpu_t::common>::common_int_vector_size
class common_type_helper<T1, T2, N1, N2> Helper for std::common_type deduction between vectors and scalars.
class common_type_helper<T1, T2, N, N> Same-width vectors share a vec<common, N> common type.
class common_type_helper<T1, vec<T2, N2>, N1, N2> Scalar vs. vector of differing widths form a nested vec<vec<...>> .
class common_type_helper<vec<T1, N2>, T2, N1, N2> Vector vs. scalar of differing widths form a nested vec<vec<...>> .
class ::std::common_type<kfr::complex<T1>, kfr::complex<T2>> common_type of two kfr::complex values.
class ::std::common_type<kfr::complex<T1>, kfr::vec<T2, N>> common_type of a kfr::complex and a kfr::vec.
class ::std::common_type<kfr::complex<T1>, T2> common_type of a kfr::complex and a scalar.
class ::std::common_type<kfr::vec<T1, N1>, kfr::vec<T2, N2>>
class ::std::common_type<kfr::vec<T1, N>, kfr::complex<T2>> common_type of a kfr::vec and a kfr::complex.
class ::std::common_type<kfr::vec<T1, N>, T2>
class ::std::common_type<T1, kfr::complex<T2>> common_type of a scalar and a kfr::complex.
class ::std::common_type<T1, kfr::vec<T2, N>>
class compound_type_traits<kfr::vec_shape<T, N>> compound_type_traits specialization for vec_shape<T, N> .
class compound_type_traits<kfr::vec<T, N>> compound_type_traits specialization for vec<T, N> .
class compound_type_traits<std::complex<T>> Traits specialization for std::complex<T> enabling KFR's compound-type machinery.
function concat2(const vec<T, N1> &, const vec<T, N2> &) Concatenates two vectors into a single vector.
function concat4(const vec<T, N> &, const vec<T, N> &, const vec<T, N> &, const vec<T, N> &) Concatenates four equal-length vectors into a single vector.
function concat_and_slice(const vec<T, N1> &, const vec<T, N2> &) Concatenates two vectors of unequal length (first shorter) and extracts a slice.
function concat_and_slice(const vec<T, N> &, const vec<T, N> &) Concatenates two equal-length vectors and extracts a slice of length count.
function concat(const vec<T, Ns> &...) Concatenates any number of vectors into a single vector.
variable cones Instance of cones_t.
struct cones_t Tag type selecting all-ones initialization.
typedef struct_with_alignment<T, A>::const_pointer Const pointer to this wrapper type.
typedef struct_with_alignment<T, false>::const_pointer Const pointer to this wrapper type.
class constants<T> Constants for the SIMD type T , inheriting from the scalar constants of its element type.
class construct_common_type<CT, Tpl> Helper that maps a common-type result onto a single-argument template.
class construct_common_type<CT, Tpl>
function copysign(const vec<T, N> &, const vec<T, N> &) Compose x with the magnitude of x and the sign of y .
variable cpu_all Compile-time list of all CPU instruction sets supported by the current architecture that are not newer than cpu_t::native .
function cpu_name(cpu_t) Returns the name of the given CPU instruction set.
enum cpu_t Enumeration representing a CPU instruction set.
variable cpuval Compile-time constant instance of cpuval_t .
typedef cpuval_t Compile-time wrapper around a cpu_t value (alias).
function cswapreim(const vec<complex<T>, N> &) Returns vector of complex values with real and imaginary parts swapped
function ctranspose(const vec<T, N> &) Complex transpose: transposes pairs of adjacent lanes viewed as complex (real, imag).
function ctransposeinverse(const vec<T, N> &) Inverse complex transpose.
function cub(const T1 &) Returns cube of x.
variable cunaligned Instance of cunaligned_t.
typedef cunaligned_t Compile-time boolean tag selecting unaligned access.
variable czeros Instance of czeros_t.
struct czeros_t Tag type selecting zero-initialization.

D¶

typedef decay_common Decays to the common type of the supplied arguments after decay.
typedef compound_type_traits<kfr::vec_shape<T, N>>::deep_rebind
typedef compound_type_traits<kfr::vec<T, N>>::deep_rebind
typedef compound_type_traits<std::complex<T>>::deep_rebind Rebinds the complex to hold values of the deep-rebound subtype of
typedef compound_type_traits<kfr::vec_shape<T, N>>::deep_subtype
typedef compound_type_traits<kfr::vec<T, N>>::deep_subtype
typedef compound_type_traits<std::complex<T>>::deep_subtype Deepest scalar component type after full recursion.
variable compound_type_traits<kfr::vec_shape<T, N>>::deep_width
variable compound_type_traits<kfr::vec<T, N>>::deep_width
variable compound_type_traits<std::complex<T>>::deep_width Width after fully recursing into the subtype.
variable scalar_constants<T>::degtorad Degrees to radians conversion factor (π / 180).
variable compound_type_traits<kfr::vec_shape<T, N>>::depth
variable compound_type_traits<kfr::vec<T, N>>::depth
variable compound_type_traits<std::complex<T>>::depth Recursion depth of the compound type.
function digitreverse4(const vec<T, N> &) Reorders the elements of a vector by reversing base-4 (quaternary) digits of their indices.
function digitreverse4(u32) Reverses the digits of the given unsigned integer in base-4 (quaternary), using the lowest bits digits.
function digitreverse(const vec<T, N> &) Reorders the elements of a vector by reversing the digits of their indices in the specified radix.
function div(const T1 &, const T2 &) Division of x by y .
typedef opencl_names::double16
typedef opencl_names::double2
typedef opencl_names::double3
typedef opencl_names::double4
typedef opencl_names::double8
function dup(const vec<T, N> &) Duplicates each element of x into a pair of adjacent lanes.
function dupeven(const vec<T, N> &) Duplicates each even-indexed element into the following odd-indexed lane.
function duphalves(const vec<T, N> &) Duplicates the contents of x to form a vector twice as long.
function duphigh(const vec<T, N> &) Duplicates the upper half of x to fill the whole vector.
function duplow(const vec<T, N> &) Duplicates the lower half of x to fill the whole vector.
function dupodd(const vec<T, N> &) Duplicates each odd-indexed element into the preceding even-indexed lane.
typedef glsl_names::dvec2
typedef glsl_names::dvec3
typedef glsl_names::dvec4

E¶

variable scalar_constants<T>::e The mathematical constant e (Euler's number).
variable portable_vec<T, N>::elem
struct vec<T, N>::element Proxy reference to a single vector element enabling read/write access.
function enumerate() Generates a vector with an arithmetic sequence of values.
function enumerate(vec_shape<T, N>) Shape-driven overload of enumerate() for type deduction.
function enumerate(vec_shape<T, N>, std::type_identity_t<T>) Generates a vector with an arithmetic sequence using a runtime step.
variable scalar_constants<T>::epsilon The machine epsilon — the smallest value such that 1 + epsilon ≠ 1.
function equal(const T1 &, const T2 &) Element-wise equality comparison.
function even(const vec<T, N> &) Extracts the even-indexed elements of x (with optional grouping).
function extend(const vec<T, 1> &) Extends a single-element vector to length Nout by repeating its value.
function extend(const vec<T, N> &) Resizes a multi-element vector to length Nout by cyclic repetition or truncation.
function extend(const vec<T, N> &) Identity overload of extend() for the Nout == N case.

F¶

struct f16 16-bit half-precision floating-point value stored as raw bits.
constructor f16::f16() Default constructor leaving the value uninitialized.
constructor f16::f16(f32) Converts a single-precision value to IEEE 754 binary16.
typedef f32x1 Short alias for vec<T, N> .
typedef f32x16
typedef f32x2
typedef f32x2x2
typedef f32x3
typedef f32x32
typedef f32x4
typedef f32x4x4
typedef f32x64
typedef f32x8
typedef f64x1
typedef f64x16
typedef f64x2
typedef f64x2x2
typedef f64x3
typedef f64x32
typedef f64x4
typedef f64x4x4
typedef f64x64
typedef f64x8
variable platform<cpu_t::common>::fast_unaligned
variable platform<cpu_t::avx>::fast_unaligned
function fbitcast(const From &) Reinterpret the bits of a scalar value as its floating-point counterpart type.
function fbitcast(const vec<From, N> &) Reinterpret the bits of a vector as a vector of its floating-point counterpart type.
function vec<T, N>::flatten()
function flatten(const vec<From, N> &)
typedef opencl_names::float16
typedef opencl_names::float2
typedef opencl_names::float3
typedef opencl_names::float4
typedef opencl_names::float8
variable float_types
variable float_vector_types Instance of float_vector_types_t for use as a value parameter pack.
typedef float_vector_types_t Type list of floating-point vector instantiations for the test sizes.
function floor(const T1 &) Returns the largest integer value not greater than x.
function fmadd(const T1 &, const T2 &, const T3 &) Fused multiply-add.
function fmod(const T &, const T &) Returns the floating-point remainder of dividing x by y.
function fmsub(const T1 &, const T2 &, const T3 &) Fused multiply-subtract.
variable scalar_constants<T>::fold_constant_div Constant π/2 used as the folding divisor in trigonometric argument reduction.
variable scalar_constants<T>::fold_constant_hi High part of the π/2 folding constant (Cody-Waite reduction).
variable scalar_constants<T>::fold_constant_rem1 First remainder term of the π/2 folding constant (Cody-Waite reduction).
variable scalar_constants<T>::fold_constant_rem2 Second remainder term of the π/2 folding constant (Cody-Waite reduction).
variable force_compiletime_size_t Forces a compile-time evaluation of the given size_t value.
function fract(const T1 &) Returns the fractional part of x.
function vec<T, N>::from_flatten(const vec<ST, SN> &) Reconstruct a (possibly compound) vector from a flat scalar vector.
struct from_lambda Tag type used to select the vec constructor that initializes elements from an index-based generator function.
function from_maskbits(T) Interprets value as a signed integer and tests the sign bit.
function f16::from_raw(u16)
function vec<T, N>::frombits(const vec<U, M> &) Reinterpret the bits of v as a vector of this type.
function portable_vec<T, N>::front()
function portable_vec<T, N>::front()
function vec<T, N>::front() Read the first element from a const lvalue vector.
function vec<T, N>::front() Read the first element from an rvalue vector.
function vec<T, N>::front() Access the first element of a non-const lvalue vector.

G¶

function gather_stride(const T *) Gathers Nout elements from base at compile-time stride Stride.
function gather_stride(const T *, size_t) Gathers Nout groups of groupsize contiguous elements from base separated by stride.
function gather(const T *) Gathers elements from base at the given compile-time indices.
function gather(const T *, const vec<IT, N> &) Gathers N groups of groupsize contiguous elements from base using a vector of offsets.
function gather(const T *, const vec<u32, N> &) Gathers elements from base using a vector of indices.
function gather(const T *, size_t, Indices...) Gathers elements from base at the given runtime indices.
function generate_vector() Generates a vector of length Nout by invoking Fn at each compile-time index.
enum constant cpu_t::generic
function vec<T, N>::get() Get element at compile-time index (template parameter form).
typedef fn_generic::get_first
typedef fn_generic::get_second
typedef fn_generic::get_third
function representation<fmt_t<kfr::complex<T>, t, width, prec>>::get(const fmt_t<kfr::complex<T>, t, width, prec> &) Converts a formatted complex value to its string form.
function representation<fmt_t<kfr::generic::vec<T, N>, t, width, prec>>::get(const fmt_t<kfr::generic::vec<T, N>, t, width, prec> &)
function representation<kfr::complex<T>>::get(const kfr::complex<T> &) Converts a complex value to its string form.
function representation<kfr::generic::mask<T, N>>::get(const kfr::generic::mask<T, N> &)
function representation<kfr::generic::vec<T, N>>::get(const kfr::generic::vec<T, N> &)
function vec<T, N>::get(csize_t<index>) Get element at compile-time index (compound element type).
function vec<T, N>::get(size_t) Get element at runtime index (compound element type).
function greater(const T1 &, const T2 &) Element-wise greater-than comparison.
function greaterorequal(const T1 &, const T2 &) Element-wise greater-or-equal comparison.

H¶

variable vec<T, N>::(Anonymous union at simd/vec.hpp:831:5)::h
function hadd(const vec<T, N> &) Computes the sum of all elements in the vector.
function havg(const vec<T, N> &) Computes the arithmetic mean (average) of all elements in the vector.
function hbitwiseand(const vec<T, N> &) Computes the bitwise AND of all elements in the vector.
function hbitwiseor(const vec<T, N> &) Computes the bitwise OR of all elements in the vector.
function hbitwisexor(const vec<T, N> &) Computes the bitwise XOR of all elements in the vector.
function hdot(const vec<T, N> &, const vec<T, N> &) Computes the dot product of two vectors.
variable vec_halves<T, N>::high Upper (remainder) half.
function special_scalar_constants<T>::highbitmask() Returns a value with only the most significant bit set.
function special_scalar_constants<float>::highbitmask() Returns negative zero, whose sign bit is set.
function special_scalar_constants<double>::highbitmask() Returns negative zero, whose sign bit is set.
function special_scalar_constants<bit<T>>::highbitmask() Mask with only the most significant bit set, expressed as a bit.
function high(const vec<T, N> &) Extracts the high subvector of x with non-power-of-two-aware sizing.
enum constant cpu_t::highest
function highhalf(const vec<T, N> &) Extracts the upper half of x.
function highhalf(vec_shape<T, N>) Shape-only overload of highhalf() for type deduction.
function high(vec_shape<T, N>) Shape-only overload of high() for type deduction.
function hmax(const vec<T, N> &) Computes the maximum element in the vector.
function hmin(const vec<T, N> &) Computes the minimum element in the vector.
function hmul(const vec<T, N> &) Computes the product of all elements in the vector.
function horizontal(const vec<T, N> &, ReduceFn &&) Applies a reduction function horizontally across all elements of the vector.
function horner_even(const T1 &, const Ts &...) Calculate polynomial using Horner's method (even powers)
function horner_odd(const T1 &, const Ts &...) Calculate polynomial using Horner's method (odd powers)
function horner(const T1 &, const Ts &...) Calculate polynomial using Horner's method
function hproduct(const vec<T, N> &) Computes the product of all elements in the vector.
function hrms(const vec<T, N> &) Computes the root-mean-square (RMS) of the vector elements.
function hsum(const vec<T, N> &) Computes the sum of all elements in the vector.

I¶

typedef i16x1
typedef i16x16
typedef i16x2
typedef i16x2x2
typedef i16x3
typedef i16x32
typedef i16x4
typedef i16x4x4
typedef i16x64
typedef i16x8
struct i24 Signed 24-bit integer stored in three bytes (little-endian).
constructor i24::i24() Default constructor leaving the value uninitialized.
constructor i24::i24(i32) Construct from a 32-bit signed integer, truncating to 24 bits.
typedef i32x1
typedef i32x16
typedef i32x2
typedef i32x2x2
typedef i32x3
typedef i32x32
typedef i32x4
typedef i32x4x4
typedef i32x64
typedef i32x8
typedef i64x1
typedef i64x16
typedef i64x2
typedef i64x2x2
typedef i64x3
typedef i64x32
typedef i64x4
typedef i64x4x4
typedef i64x64
typedef i64x8
typedef i8x1
typedef i8x16
typedef i8x2
typedef i8x2x2
typedef i8x3
typedef i8x32
typedef i8x4
typedef i8x4x4
typedef i8x64
typedef i8x8
function ibitcast(const From &) Reinterpret the bits of a scalar value as its signed counterpart type.
function ibitcast(const vec<From, N> &) Reinterpret the bits of a vector as a vector of its signed counterpart type.
function iceil(const T1 &) Returns the smallest integer value not less than x, as an integer type.
function ifloor(const T1 &) Returns the largest integer value not greater than x, as an integer type.
function imag(const complex<T> &) Returns the imaginary part of the complex value
function imag(const vec<complex<T>, N> &) Returns the imaginary parts of a vector of complex values.
variable vec<T, N>::element::index Element index within
variable index_undefined Sentinel index value meaning "no index".
variable infinity Positive infinity as a double .
variable scalar_constants<T>::infinity The representation of positive infinity for the type T.
class initialvalue<T> Used to determine the initial value for reduce functions.
function inrange(const T1 &, const T2 &, const T3 &) Test whether each element lies within a closed range.
function inserthigh(T, const vec<T, N> &) Inserts a scalar x at the high (right) end of y, shifting y one lane to the low (left) side.
function insertleft(T, const vec<T, N> &) Legacy alias for insertlow().
function insertlow(T, const vec<T, N> &) Inserts a scalar x at the low (left) end of y, shifting y one lane to the high (right) side.
function insertright(T, const vec<T, N> &) Legacy alias for inserthigh().
typedef opencl_names::int16
typedef opencl_names::int2
typedef opencl_names::int3
typedef opencl_names::int4
typedef opencl_names::int8
variable integer_types Type list of all integer element types (signed and unsigned).
variable integer_vector_types Instance of integer_vector_types_t for use as a value parameter pack.
typedef integer_vector_types_t Type list of all integer vector instantiations for the test sizes.
function interleave(const vec<T, N> &, const vec<T, N> &) Interleaves the lanes of two equal-length vectors x and y.
function interleavehalves(const vec<T, N> &) Interleaves the two halves of x.
function special_scalar_constants<T>::invhighbitmask() Returns a value with every bit except the most significant bit set.
function special_scalar_constants<float>::invhighbitmask() Returns a floating-point value with every bit except the sign bit set.
function special_scalar_constants<double>::invhighbitmask() Returns a floating-point value with every bit except the sign bit set.
function special_scalar_constants<bit<T>>::invhighbitmask() Inverse of highbitmask, i.e. all bits except the high bit set.
function ipow(const T &, int) Integer power.
function iround(const T1 &) Returns the nearest integer value to x, as an integer type.
variable is_bit True when T is a bit<U> specialization.
variable is_complex Variable template: true if T is a complex specialization.
variable compound_type_traits<kfr::vec_shape<T, N>>::is_scalar
variable compound_type_traits<kfr::vec<T, N>>::is_scalar
variable compound_type_traits<std::complex<T>>::is_scalar because a complex value is not a scalar.
variable is_simd_float_type True when T is a floating-point SIMD element type.
variable is_simd_int_type True when T is an integer SIMD element type.
function is_simd_size(size_t) Checks whether size is a valid SIMD vector size for type T.
variable is_simd_type True when T is one of the scalar types usable as a SIMD element.
variable is_vec True if T is a vec instantiation.
variable is_vec_element True if T (after stripping cv) is usable as a vec element type.
function isfinite(const vec<T, N> &) Detect finite values element-wise.
function isinf(const vec<T, N> &) Detect infinite values element-wise.
function isnan(const vec<T, N> &) Detect NaN (Not-a-Number) values element-wise.
function isnegative(const vec<T, N> &) Detect negative values element-wise by inspecting the sign bit.
function ispositive(const vec<T, N> &) Detect non-negative values element-wise.
function isreal(const complex<T> &) Returns mask with true for real elements
function iszero(const vec<T, N> &) Detect zero values element-wise.
function itrunc(const T1 &) Returns the truncated integer part of x, as an integer type.
typedef vec<T, N>::iuscalar_type
typedef vec<T, N>::iusimd_type
typedef vec<T, N>::iuvalue_type
typedef glsl_names::ivec2
typedef glsl_names::ivec3
typedef glsl_names::ivec4

K¶

L¶

function less(const T1 &, const T2 &) Element-wise less-than comparison.
function lessorequal(const T1 &, const T2 &) Element-wise less-or-equal comparison.
variable scalar_constants<T>::log_10 The natural logarithm of 10 (ln(10)).
variable scalar_constants<T>::log_2 The natural logarithm of 2 (ln(2)).
typedef opencl_names::long16
typedef opencl_names::long2
typedef opencl_names::long3
typedef opencl_names::long4
typedef opencl_names::long8
variable vec_halves<T, N>::low Lower (power-of-two) half.
function low(const vec<T, N> &) Extracts the largest power-of-two-sized low subvector of x.
enum constant cpu_t::lowest
function lowhalf(const vec<T, N> &) Extracts the lower half of x.
function lowhalf(vec_shape<T, N>) Shape-only overload of lowhalf() for type deduction.
function low(vec_shape<T, N>) Shape-only overload of low() for type deduction.

M¶

function make_complex(const vec<T1, N> &, const vec<T2, N> &) Constructs a vector of complex values from real and imaginary vectors.
function make_complex(T1, T2) Constructs a complex value from real and imaginary scalars.
function make_mask(bool, Args...) Constructs a SIMD mask vector from boolean values.
function make_vector(const Arg &, const Args &...) Create a vector from scalar values.
function make_vector(const vec<T, N> &) Identity overload: returns the passed vector unchanged.
function make_vector(cvals_t<T, Values...>) Create a vector from a compile-time constant list.
typedef mask SIMD mask type of T elements with default width vector_width .
variable platform<cpu_t::common>::mask_registers
variable platform<cpu_t::avx512>::mask_registers
typedef vec<T, N>::mask_t
function maskbits(bool) Returns all-ones or all-zeros of type T depending on value.
typedef maskfor Obtains the mask type associated with a SIMD type.
typedef mat Matrix alias: a vector of vectors, N2 rows of N1 columns.
variable max_test_size Maximum vector size (in elements) exercised by the test suite for the current architecture.
function max(const T1 &, const T2 &) Returns the greater of two values.
variable platform<cpu_t::common>::maximum_vector_alignment
variable platform<cpu_t::common>::maximum_vector_alignment_mask
variable maximum_vector_size
function min(const T1 &, const T2 &) Returns the smaller of two values.
variable platform<cpu_t::common>::minimum_float_vector_size
variable platform<cpu_t::common>::minimum_int_vector_size
variable minimum_vector_width Minimum SIMD vector width (in elements) for type T on the native platform.
function mix(const T1 &, const T2 &, const T3 &) Linear blend of x and y .
function mixs(const T1 &, const T2 &, const T3 &) Signed linear blend of x and y .
function mod(const T1 &, const T2 &) Modulo of x by y .
function mul(const T1 &) Identity mul (single argument).
function mul(const T1 &, const T2 &, const Ts &...) Returns product of all the arguments passed to a function.
function mul(initialvalue<T>) Identity element for mul (returns one).
function mulsign(const T1 &, const T2 &) Multiply x by the sign of y without a conditional branch.

N¶

function narrow(const vec<T, N> &) Narrows x to length Nout by truncation.
enum constant cpu_t::native
variable platform<cpu_t::common>::native_cache_alignment
variable platform<cpu_t::common>::native_cache_alignment_mask
variable platform<cpu_t::common>::native_float_vector_size
variable platform<cpu_t::avx>::native_float_vector_size
variable platform<cpu_t::avx512>::native_float_vector_size
variable platform<cpu_t::common>::native_int_vector_size
variable platform<cpu_t::avx2>::native_int_vector_size
variable platform<cpu_t::avx512>::native_int_vector_size
variable platform<cpu_t::common>::native_vector_alignment
variable platform<cpu_t::avx>::native_vector_alignment
variable platform<cpu_t::avx512>::native_vector_alignment
variable platform<cpu_t::common>::native_vector_alignment_mask
variable platform<cpu_t::avx>::native_vector_alignment_mask
variable platform<cpu_t::avx512>::native_vector_alignment_mask
class native_vector_type<T>
function neg(const T1 &) Arithmetic negation of x .
function negeven(const vec<T, N> &) Negates the even-indexed lanes of x .
variable scalar_constants<T>::neginfinity The representation of negative infinity for the type T.
function negodd(const vec<T, N> &) Negates the odd-indexed lanes of x .
typedef fn_generic::noop
function notequal(const T1 &, const T2 &) Element-wise inequality comparison.
variable numeric_types
variable numeric_vector_types Instance combining integer and floating-point vector types for use as a value parameter pack.

O¶

function odd(const vec<T, N> &) Extracts the odd-indexed elements of x (with optional grouping).
function onoff(cint_t<on>, cint_t<off>) Generates a vector with an on/off pattern over a contiguous range.
function onoff(vec_shape<T, N>, cint_t<on>, cint_t<off>) Shape-driven overload of onoff() for type deduction.
function vec<T, N>::element::operator+() Unary plus (returns the value).
function vec<T, N>::element::operator-() Unary negation.
function vec<T, N>::element::operator++() Pre-increment.
function vec<T, N>::element::operator--() Pre-decrement.
operator bit<T>::operator Converts to bool by testing the sign bit of the stored mask.
function bit<T>::operator==(bool) Equality comparison against a plain bool.
function bit<T>::operator!=(bool) Inequality comparison against a plain bool.
function bit<T>::operator==(const bit<T> &) Equality comparison between two bit values.
function bit<T>::operator!=(const bit<T> &) Inequality comparison between two bit values.
function vec<T, N>::element::operator=(const element &) Copy-assign from another element proxy.
function operator&(const mask<T1, N> &, const mask<T2, N> &) Bitwise AND of two masks (bit-level, size must match).
function operator|(const mask<T1, N> &, const mask<T2, N> &) Bitwise OR of two masks (bit-level, size must match).
function operator&&(const mask<T1, N> &, const mask<T2, N> &) Logical AND of two masks (bit-level conjunction, size must match).
function operator||(const mask<T1, N> &, const mask<T2, N> &) Logical OR of two masks (bit-level disjunction, size must match).
function operator^(const mask<T1, N> &, const mask<T2, N> &) Bitwise XOR of two masks (bit-level, size must match).
function operator~(const mask<T, N> &) Bitwise NOT of a mask.
function operator!(const mask<T, N> &) Logical NOT of a mask (equivalent to bitwise NOT).
function portable_vec<T, N>::operator==(const portable_vec<T, N> &)
function operator+(const T1 &, const vec<T2, N> &)
function operator-(const T1 &, const vec<T2, N> &)
function operator*(const T1 &, const vec<T2, N> &)
function operator/(const T1 &, const vec<T2, N> &)
function operator%(const T1 &, const vec<T2, N> &)
function operator&(const T1 &, const vec<T2, N> &)
function operator|(const T1 &, const vec<T2, N> &)
function operator^(const T1 &, const vec<T2, N> &)
function operator<<(const T1 &, const vec<T2, N> &)
function operator>>(const T1 &, const vec<T2, N> &)
function operator==(const T1 &, const vec<T2, N> &)
function operator!=(const T1 &, const vec<T2, N> &)
function operator>=(const T1 &, const vec<T2, N> &)
function operator<=(const T1 &, const vec<T2, N> &)
function operator>(const T1 &, const vec<T2, N> &)
function operator<(const T1 &, const vec<T2, N> &)
function vec<T, N>::element::operator=(const typename vec<U, M>::element &) Assign from an element proxy of a different vector type.
function vec<T, N>::element::operator=(const value_type &) Assign a scalar to the referenced element.
function vec<T, N>::element::operator+=(const value_type &) Add-assign a scalar.
function vec<T, N>::element::operator-=(const value_type &) Subtract-assign a scalar.
function vec<T, N>::element::operator*=(const value_type &) Multiply-assign a scalar.
function vec<T, N>::element::operator/=(const value_type &) Divide-assign a scalar.
function operator+(const vec<T1, N> &, const T2 &)
function operator-(const vec<T1, N> &, const T2 &)
function operator*(const vec<T1, N> &, const T2 &)
function operator/(const vec<T1, N> &, const T2 &)
function operator%(const vec<T1, N> &, const T2 &)
function operator&(const vec<T1, N> &, const T2 &)
function operator|(const vec<T1, N> &, const T2 &)
function operator^(const vec<T1, N> &, const T2 &)
function operator==(const vec<T1, N> &, const T2 &)
function operator!=(const vec<T1, N> &, const T2 &)
function operator>=(const vec<T1, N> &, const T2 &)
function operator<=(const vec<T1, N> &, const T2 &)
function operator>(const vec<T1, N> &, const T2 &)
function operator<(const vec<T1, N> &, const T2 &)
function operator+(const vec<T1, N> &, const vec<T2, N> &)
function operator-(const vec<T1, N> &, const vec<T2, N> &)
function operator*(const vec<T1, N> &, const vec<T2, N> &)
function operator/(const vec<T1, N> &, const vec<T2, N> &)
function operator%(const vec<T1, N> &, const vec<T2, N> &)
function operator&(const vec<T1, N> &, const vec<T2, N> &)
function operator|(const vec<T1, N> &, const vec<T2, N> &)
function operator^(const vec<T1, N> &, const vec<T2, N> &)
function operator<<(const vec<T1, N> &, const vec<T2, N> &)
function operator>>(const vec<T1, N> &, const vec<T2, N> &)
function operator==(const vec<T1, N> &, const vec<T2, N> &)
function operator!=(const vec<T1, N> &, const vec<T2, N> &)
function operator>=(const vec<T1, N> &, const vec<T2, N> &)
function operator<=(const vec<T1, N> &, const vec<T2, N> &)
function operator>(const vec<T1, N> &, const vec<T2, N> &)
function operator<(const vec<T1, N> &, const vec<T2, N> &)
function operator<<(const vec<T1, N> &, unsigned int)
function operator>>(const vec<T1, N> &, unsigned int)
function vec<T, N>::operator=(const vec<T, N> &) Copy assignment operator.
function operator-(const vec<T, N> &)
function operator~(const vec<T, N> &)
operator f16::operator Converts this IEEE 754 binary16 value to single precision.
operator i24::operator Implicit conversion to int via as_int().
function vec<T, N>::element::operator++(int) Post-increment.
function vec<T, N>::element::operator--(int) Post-decrement.
operator vec<T, N>::operator Convert to a layout-compatible portable_vec .
function portable_vec<T, N>::operator[](size_t)
function portable_vec<T, N>::operator[](size_t)
function vec<T, N>::operator[](size_t) Read element at index from a const lvalue vector.
function vec<T, N>::operator[](size_t) Read element at index from an rvalue vector.
function vec<T, N>::operator[](size_t) Access element at index from a non-const lvalue vector.
function vec<T, N>::element::operator[](size_t) Index into a compound element (nested vector).
function struct_with_alignment<T, A>::operator=(T) Assigns a new value to the wrapped member.
function struct_with_alignment<T, false>::operator=(T) Assigns a new value to the wrapped member.
operator bit<T>::operator
operator vec<T, N>::element::operator Read the referenced element.
function operator+=(vec<T1, N> &, const T2 &)
function operator-=(vec<T1, N> &, const T2 &)
function operator*=(vec<T1, N> &, const T2 &)
function operator/=(vec<T1, N> &, const T2 &)
function operator%=(vec<T1, N> &, const T2 &)
function operator&=(vec<T1, N> &, const T2 &)
function operator|=(vec<T1, N> &, const T2 &)
function operator^=(vec<T1, N> &, const T2 &)
function operator+=(vec<T1, N> &, const vec<T2, N> &)
function operator-=(vec<T1, N> &, const vec<T2, N> &)
function operator*=(vec<T1, N> &, const vec<T2, N> &)
function operator/=(vec<T1, N> &, const vec<T2, N> &)
function operator%=(vec<T1, N> &, const vec<T2, N> &)
function operator&=(vec<T1, N> &, const vec<T2, N> &)
function operator|=(vec<T1, N> &, const vec<T2, N> &)
function operator^=(vec<T1, N> &, const vec<T2, N> &)
function operator<<=(vec<T1, N> &, const vec<T2, N> &)
function operator>>=(vec<T1, N> &, const vec<T2, N> &)
function operator<<=(vec<T1, N> &, unsigned int)
function operator>>=(vec<T1, N> &, unsigned int)
function vec<T, N>::operator=(vec<T, N> &&) Move assignment operator.
function optimized_bitshuffle(const vec<T, N> &) Internal ADL-provided implementation for bit-shuffle expressions.

P¶

function pack(const Arg &, const Args &...) Pack scalar values into a vector of numeric type.
function packtranspose(const vec<T, N1> &, const vec<T, Ns> &...) Transposes and packs sizeof...(Ns)+1 vectors of length N1 into a vector of vectors of length N1 .
function padhigh(const vec<T, N> &) Pads x with Ncount zero-initialized lanes on the high side.
function padhigh(const vec<T, N> &, std::type_identity_t<T>) Pads x with Ncount copies of newvalue on the high side.
function padlow(const vec<T, N> &) Pads x with Ncount zero-initialized lanes on the low side.
function padlow(const vec<T, N> &, std::type_identity_t<T>) Pads x with Ncount copies of newvalue on the low side.
function part(const vec<T, N> &) Extracts the number-th of total equal-sized parts of x.
variable partial_masks Lookup table used by partial_mask to build vectors with a leading run of all-ones elements.
function partial_mask(size_t) Returns a vector of N elements with index leading all-ones elements followed by zeros.
function partial_mask(size_t, vec_shape<T, N>) Returns a vector of N elements with index leading all-ones elements followed by zeros.
function partial_read(const T *, size_t) Reads up to count elements into a vector.
function partial_write(T *, const vec<T, N> &, size_t) Writes up to count leading elements of a vector to memory.
typedef fn_generic::pass_through
function permute(const vec<T, N> &, elements_t<Indices...>) Permutes the lanes of x using a repeating index pattern.
function permutegroups(const vec<T, N> &, elements_t<Indices...>) Group-wise variant of permute() that operates on blocks of group elements.
variable scalar_constants<T>::pi The mathematical constant π (pi).
function scalar_constants<T>::pi_s(int, int) Returns π scaled by m / d .
class pkd_vec<T, N> Packed storage for a vector with no alignment padding.
constructor pkd_vec<T, N>::pkd_vec<T, N>() Default constructor (uninitialized).
constructor pkd_vec<T, N>::pkd_vec<T, N>(const vec<T, N> &) Store a vec into this packed storage.
function pkd_vec<T, N>::pkd_vec<T, N>(Ts...) Initialize from up to N scalar values.
class platform<c> Trait structure describing the SIMD capabilities of a CPU instruction set.
struct platform<cpu_t::avx> Platform traits for AVX. Doubles the native float vector size and alignment to 32 bytes and enables fast unaligned access.
struct platform<cpu_t::avx2> Platform traits for AVX2. Extends AVX with 256-bit integer vectors.
struct platform<cpu_t::avx512> Platform traits for AVX-512. Provides 512-bit vectors, 64-byte alignment, mask register support and an increased register count.
struct platform<cpu_t::common> Platform traits for the common (baseline) x86 instruction set.
struct platform<cpu_t::sse2> Platform traits for SSE2. Inherits the common baseline and reports the SSE2 register count.
struct platform<cpu_t::sse3> Platform traits for SSE3. Equivalent to SSE2.
struct platform<cpu_t::sse41> Platform traits for SSE4.1. Equivalent to SSSE3.
struct platform<cpu_t::sse42> Platform traits for SSE4.2. Equivalent to SSE4.1.
struct platform<cpu_t::ssse3> Platform traits for SSSE3. Equivalent to SSE3.
typedef struct_with_alignment<T, A>::pointer Pointer to this wrapper type.
typedef struct_with_alignment<T, false>::pointer Pointer to this wrapper type.
class portable_vec<T, N> A portable vector type with fixed size and layout compatible with vec<T, N> .
constructor portable_vec<T, N>::portable_vec<T, N>()
constructor portable_vec<T, N>::portable_vec<T, N>(T)
function portable_vec<T, N>::portable_vec<T, N>(T, T, Ts...)
function pow2(const T &) Returns \(x^2\) .
function pow3(const T &) Returns \(x^3\) .
function pow4(const T &) Returns \(x^4\) .
function pow5(const T &) Returns \(x^5\) .
function promoteto(const Tin &) Promote a scalar to Tout .
function promoteto(const vec<Tin, N> &) Promote a vector to a different element type.
function promoteto(const vec<vec<Tin, N1>, N2> &) Promote a nested vector to a different element type.
variable stride_pointer<const T, groupsize>::ptr Pointer to the first element.

Q¶

variable qnan Quiet NaN (Not-a-Number) as a double .
variable scalar_constants<T>::qnan A quiet NaN (Not-a-Number) value for the type T. This value does not raise floating-point exceptions.

R¶

variable scalar_constants<T>::radtodeg Radians to degrees conversion factor (π * 180).
variable u24::raw Raw byte storage.
variable i24::raw Raw byte storage.
variable f16::raw Raw bit representation of the half-precision value.
function read_group(const T *, size_t) Reads count groups of group*N elements separated by stride groups.
function read(const T *) Reads a vector of N elements of type T from memory.
function stride_pointer<const T, groupsize>::read(csize_t<N>) Gathers N elements from the underlying pointer using the stored stride.
function real(const complex<T> &) Returns the real part of the complex value
function real(const T &) Returns the real part of the complex value
function real(const vec<complex<T>, N> &) Returns the real parts of a vector of complex values.
typedef realftype Alias for ftype<decltype(kfr::real(std::declval<T>()))>
typedef realtype Alias for decltype(kfr::real(std::declval<T>()))
typedef compound_type_traits<kfr::vec_shape<T, N>>::rebind
typedef compound_type_traits<kfr::vec<T, N>>::rebind
typedef compound_type_traits<std::complex<T>>::rebind Rebinds the complex to hold values of type
variable scalar_constants<T>::recip_log_10 The reciprocal of the natural logarithm of 10 (1 / ln(10)).
variable scalar_constants<T>::recip_log_2 The reciprocal of the natural logarithm of 2 (1 / ln(2)).
variable scalar_constants<T>::recip_pi The reciprocal of π (1/π).
function scalar_constants<T>::recip_pi_s(int, int) Returns the reciprocal of π scaled by m / d .
function reciprocal(const T &) Multiplicative inverse of x .
function rem(const T1 &, const T2 &) Remainder of x divided by y .
function rem(const vec<T, N> &, const vec<T, N> &) Returns the element-wise floating-point remainder of vectors x and y.
function repeat(const vec<T, N> &) Repeats the contents of x count times.
function replace(const vec<T, N> &, const vec<T, N> &) Replaces a contiguous range of x with the corresponding lanes of y.
class representation<fmt_t<kfr::complex<T>, t, width, prec>> String representation specialization for a formatted complex value.
class representation<fmt_t<kfr::generic::vec<T, N>, t, width, prec>>
class representation<kfr::complex<T>> String representation specialization for kfr::complex<T> .
class representation<kfr::generic::mask<T, N>> String representation of a mask for formatting/logging.
class representation<kfr::generic::vec<T, N>> String representation of a vec for formatting/logging.
function resize(const vec<T, N> &) Resizes a vector to length Nout.
function resize(const vec<T, N> &) Identity overload of resize() for the Nout == N case.
typedef fn_generic::returns
function reverse(const vec<T, N> &) Reverses the order of lanes in x (with optional grouping).
function reverse(const vec<vec<T, N1>, N2> &) Reverses the order of inner vectors in a vector of vectors.
function rol(const T1 &, const T2 &) Bitwise left rotate.
function ror(const T1 &, const T2 &) Bitwise right rotate.
function rotateleft(const vec<T, N> &, csize_t<amount>) Rotates the lanes of x to the left by amount positions.
function rotateright(const vec<T, N> &, csize_t<amount>) Rotates the lanes of x to the right by amount positions.
function rotatetwo(const vec<T, N> &, const vec<T, N> &) Combines two vectors lo and hi with a rotation by shift lanes.
function round(const T1 &) Returns the nearest integer value to x.
enum constant cpu_t::runtime

S¶

function satadd(const T1 &, const T2 &) Adds two numeric values using saturation arithmetic.
function satsub(const T1 &, const T2 &) Subtracts two numeric values using saturation arithmetic.
class scalar_constants<T> Collection of mathematical and machine constants for the scalar type T .
function vec_shape<T, N>::scalar_size() Total number of scalar components, including compound element widths.
function vec<T, N>::scalar_size()
typedef vec_shape<T, N>::scalar_type Scalar component type of the element.
typedef vec<T, N>::scalar_type
function scatter_stride(T *, const vec<T, N> &, size_t) Scatters N/groupsize groups of groupsize contiguous elements of value to base separated by stride.
function scatter(const T *, const vec<T, N> &) Scatters elements of value to base at the given compile-time indices.
function scatter(T *, const vec<IT, N> &, const vec<T, Nout> &) Scatters N groups of groupsize contiguous elements of value to base using a vector of offsets.
enum constant cpu_t::secondary
function select(const mask<T1, N> &, const T2 &, const T3 &) Returns x if m is true, otherwise return y. Order of the arguments is same as in ternary operator.
function vec<T, N>::set(csize_t<index>, const value_type &) Set element at compile-time index (compound element type).
function vec<T, N>::set(size_t, const value_type &) Set element at runtime index (compound element type).
function portable_vec<T, N>::shape()
function vec<T, N>::shape()
function shl(const T1 &, const T2 &) Bitwise left shift.
typedef opencl_names::short16
typedef opencl_names::short2
typedef opencl_names::short3
typedef opencl_names::short4
typedef opencl_names::short8
function shr(const T1 &, const T2 &) Bitwise right shift.
function shuffle(const vec<T, N> &, const vec<T, N> &, elements_t<Indices...>) Shuffles the concatenation of two equal-length vectors using a repeating index pattern.
function vec<T, N>::shuffle(const vec<T, N> &, csizes_t<indices...>) Permute elements from two concatenated vectors (*this, y) .
function vec<T, N>::shuffle(csizes_t<indices...>) Permute elements of this vector according to i .
function shufflegroups(const vec<T, N> &, const vec<T, N> &, elements_t<Indices...>) Group-wise variant of shuffle() that operates on blocks of group elements.
function shuffleindexbits(const vec<T, N> &, elements_t<A...>) Shuffles lanes of x by permuting the bits of each lane index.
function shufflevector(const vec<complex<T>, N> &, csizes_t<indices...>) Shuffles the complex elements of x according to indices.
function shufflevector(const vec<T, N> &, csizes_t<indices...>) Permute elements of a single vector.
function shufflevectors(const vec<complex<T>, N> &, const vec<T, N> &, csizes_t<indices...>) Shuffles complex elements from two vectors x and y according to indices.
function shufflevectors(const vec<T, N> &, const vec<T, N> &, csizes_t<indices...>) Permute elements from two concatenated vectors.
variable signed_types Type list of all signed integer element types.
variable signed_vector_types Instance of signed_vector_types_t for use as a value parameter pack.
typedef signed_vector_types_t Type list of signed-integer vector instantiations for the test sizes.
concept simd_compat Concept satisfied by scalar types usable as SIMD elements.
variable vec<T, N>::simd_element_count Number of native lanes.
variable vec<T, N>::simd_element_size
typedef vec<T, N>::simd_element_type
variable platform<cpu_t::common>::simd_register_count
variable platform<cpu_t::sse2>::simd_register_count
variable platform<cpu_t::avx512>::simd_register_count
typedef vec<T, N>::simd_type
function vec_shape<T, N>::size() Number of elements in the vector.
function portable_vec<T, N>::size()
function vec<T, N>::size()
function size_of() Size of a (possibly compound) type measured in bytes of its deepest scalar.
function slice(const vec<T, N> &) Extracts a contiguous subvector of count elements starting at start.
function slice(const vec<T, N> &, const vec<T, N> &) Extracts a contiguous subvector spanning the concatenation of x and y.
variable vec<T, N>::SN Total scalar count.
function sort(const vec<T, N> &) Sort the elements in the vector in ascending order
function sortdesc(const vec<T, N> &) Sort the elements in the vector in descending order
class special_constants<T> Provides special constants for the scalar subtype of T.
class special_scalar_constants<bit<T>> Special scalar constants for bit<T> .
struct special_scalar_constants<double> Provides special bit-pattern constants for double .
struct special_scalar_constants<float> Provides special bit-pattern constants for float .
class special_scalar_constants<T> Provides special bit-pattern constants for a scalar type.
function split(const vec<T, N> &) Terminal overload of split() for variadic recursion.
function split(const vec<T, N> &, vec<T, N / 2> &, vec<T, N / 2> &) Splits x into two equal halves.
function split(const vec<T, N> &, vec<T, N / 4> &, vec<T, N / 4> &, vec<T, N / 4> &, vec<T, N / 4> &) Splits x into four equal quarters.
function split(const vec<T, N> &, vec<T, Nout> &, Args &&...) Splits x into consecutive subvectors written into the supplied output references.
function splitpairs(const vec<T, N> &) Deinterleaves adjacent pairs (inverse of interleavehalves with side1 == 2).
variable scalar_constants<T>::sqr_pi The square of π (pi²).
function sqr(const T1 &) Returns square of x.
function sqrdiff(const T1 &, const T2 &) Returns square of the difference of two arguments.
function sqrsum(const T1 &, const Ts &...) Square of the sum of all arguments.
variable scalar_constants<T>::sqrt_2 The square root of 2 (√2).
enum constant cpu_t::sse2
enum constant cpu_t::sse3
enum constant cpu_t::sse41
enum constant cpu_t::sse42
enum constant cpu_t::ssse3
typedef vec<T, N>::ST
variable stride_pointer<const T, groupsize>::stride Offset (in groups) between consecutive groups.
class stride_pointer<const T, groupsize> Read-only strided pointer: a pointer paired with a stride that supports grouped gather reads.
class stride_pointer<T, groupsize> Mutable strided pointer: a pointer paired with a stride that supports grouped scatter writes.
constructor stride_pointer<T, groupsize>::stride_pointer<T, groupsize>(T *, size_t)
class struct_with_alignment<T, A> Wrapper exposing a member of type T with the requested alignment.
class struct_with_alignment<T, false> Packed, unaligned specialization of struct_with_alignment.
function subadd(const vec<T, N> &, const vec<T, N> &) Returns a vector with a-b in the low half and a+b in the high half.
function sub(const T1 &, const T2 &) Subtraction of two values.
function sub(initialvalue<T>) Identity element for sub (returns zero).
typedef compound_type_traits<kfr::vec_shape<T, N>>::subtype
typedef compound_type_traits<kfr::vec<T, N>>::subtype
typedef compound_type_traits<std::complex<T>>::subtype Scalar component type of the complex value.
variable vec<T, N>::SW
function swapbyteorder(const T &) Swap byte order of x .
function swap(const vec<T, N> &) Swaps adjacent groups of elements lanes.

T¶

variable test_vector_sizes Set of vector sizes used by the test harness.
function to_vec(const portable_vec<T, N> &) Convert a portable_vec to the native vec type.
function to_vec(const std::array<T, N> &) Converts a std::array of N elements to a vector.
function transpose(const vec<T, N> &) Transposes a vector viewed as a side1 x side2 matrix (row-major).
function transpose(const vec<T, N> &) Identity overload of transpose() for small vectors (size <= 3).
function transpose(const vec<vec<T, N>, N> &) Transposes a vector of vectors (matrix of vectors).
function transposeinverse(const vec<T, N> &) Inverse transpose of a vector viewed as a side1 x side2 matrix (row-major).
function transposeinverse(const vec<T, N> &) Identity overload of transposeinverse() for small vectors (size <= 3).
function trunc(const T1 &) Returns the integer part of x by removing its fractional part.
typedef special_constants<T>::Tsub The scalar subtype used to provide the constants.
typedef constants<T>::Tsub
class ::std::tuple_element<I, kfr::vec<T, N>>
class ::std::tuple_size<kfr::vec<T, N>>
typedef construct_common_type<CT, Tpl>::type
typedef vector_types_for_size_t_impl<vec_tpl, T, csizes_t<sizes...>>::type
typedef bitmask<bits>::type The unsigned integer type selected for the requested width.
typedef native_vector_type<T>::type
typedef vec_template<N>::type
typedef vecvec_template<N1, N2>::type
typedef vec_vec_template<N1, N2>::type
typedef representation<kfr::generic::vec<T, N>>::type
typedef representation<fmt_t<kfr::generic::vec<T, N>, t, width, prec>>::type
typedef representation<kfr::generic::mask<T, N>>::type
typedef ::std::tuple_element<I, kfr::vec<T, N>>::type
typedef representation<kfr::complex<T>>::type Result type of the conversion.
typedef representation<fmt_t<kfr::complex<T>, t, width, prec>>::type Result type of the conversion.
typedef vec_of_complex<N>::type The complex vector type for component type

U¶

typedef u16x1
typedef u16x16
typedef u16x2
typedef u16x2x2
typedef u16x3
typedef u16x32
typedef u16x4
typedef u16x4x4
typedef u16x64
typedef u16x8
struct u24 Unsigned 24-bit integer stored in three bytes (little-endian).
typedef u32x1
typedef u32x16
typedef u32x2
typedef u32x2x2
typedef u32x3
typedef u32x32
typedef u32x4
typedef u32x4x4
typedef u32x64
typedef u32x8
typedef u64x1
typedef u64x16
typedef u64x2
typedef u64x2x2
typedef u64x3
typedef u64x32
typedef u64x4
typedef u64x4x4
typedef u64x64
typedef u64x8
typedef u8x1
typedef u8x16
typedef u8x2
typedef u8x2x2
typedef u8x3
typedef u8x32
typedef u8x4
typedef u8x4x4
typedef u8x64
typedef u8x8
function ubitcast(const From &) Reinterpret the bits of a scalar value as its unsigned counterpart type.
function ubitcast(const vec<From, N> &) Reinterpret the bits of a vector as a vector of its unsigned counterpart type.
typedef opencl_names::uchar16
typedef opencl_names::uchar2
typedef opencl_names::uchar3
typedef opencl_names::uchar4
typedef opencl_names::uchar8
function uibitcast(const From &) Reinterpret the bits of a scalar value as its unsigned-or-signed counterpart type.
function uibitcast(const vec<From, N> &) Reinterpret the bits of a vector as a vector of its unsigned-or-signed counterpart type.
typedef opencl_names::uint16
typedef opencl_names::uint2
typedef opencl_names::uint3
typedef opencl_names::uint4
typedef opencl_names::uint8
typedef opencl_names::ulong16
typedef opencl_names::ulong2
typedef opencl_names::ulong3
typedef opencl_names::ulong4
typedef opencl_names::ulong8
function undefinedvector() Return an uninitialized vector of the given type and size.
function undefinedvector(vec_shape<T, N>) Return an uninitialized vector matching the given shape.
variable unsigned_types Type list of all unsigned integer element types.
variable unsigned_vector_types Instance of unsigned_vector_types_t for use as a value parameter pack.
typedef unsigned_vector_types_t Type list of unsigned-integer vector instantiations for the test sizes.
typedef unwrap_bit
function unwrap_bit_value(const bit<T> &) Overload unwrapping a bit<T> to its underlying mask value.
function unwrap_bit_value(const T &) Returns the underlying mask value of a bit, or the value itself for non-bit types.
typedef vec<T, N>::uscalar_type
typedef opencl_names::ushort16
typedef opencl_names::ushort2
typedef opencl_names::ushort3
typedef opencl_names::ushort4
typedef opencl_names::ushort8
typedef vec<T, N>::usimd_type
typedef vec<T, N>::uvalue_type
typedef glsl_names::uvec2
typedef glsl_names::uvec3
typedef glsl_names::uvec4

V¶

variable vec<T, N>::element::v Owning vector.
variable vec<T, N>::(Anonymous union at simd/vec.hpp:831:5)::v
variable vec_halves<T, 1>::val The single scalar value.
variable bitmask<bits>::value The stored bit value.
variable bit<T>::value The raw mask value.
variable struct_with_alignment<T, A>::value The wrapped value.
variable struct_with_alignment<T, false>::value The wrapped value.
typedef vec_shape<T, N>::value_type The element type stored in the vector.
typedef portable_vec<T, N>::value_type
typedef vec<T, N>::value_type
deduction guide vec Deduction guide: a braced list of scalars deduces to vec<common_type, N> .
typedef glsl_names::vec2
typedef glsl_names::vec3
typedef glsl_names::vec4
class vec_halves<T, 1> Specialization of vec_halves for single-element vectors.
class vec_halves<T, N> Splits a vec<T, N> into its two halves for recursive decomposition.
class vec_of_complex<N> Helper that maps a scalar component type T to vec<complex<T>, N>.
variable vec_rank Rank of a type within the compound-vector hierarchy.
class vec_shape<T, N> Describes the shape of a SIMD vector of N elements of type T.
constructor vec_shape<T, N>::vec_shape<T, N>() Default constructor.
class vec_template<N> Alias template producing vec<T, N> for a fixed N .
class vec_vec_template<N1, N2> Alias template producing vec<vec<T, N1>, N2> for fixed N1 , N2 .
class vec<T, 0> Rejected specialization for zero-sized vectors.
class vec<T, N> SIMD vector type of T elements with default width vector_width .
constructor vec<T, N>::vec<T, N>() Default constructor (elements are left uninitialized).
constructor vec<T, N>::vec<T, N>(cones_t) Construct an all-ones vector (tag constructor).
constructor vec<T, N>::vec<T, N>(const portable_vec<T, N> &) Reinterpret a portable_vec as a vec (layout-compatible).
constructor vec<T, N>::vec<T, N>(const simd_type &) Construct from a native SIMD register.
function vec<T, N>::vec<T, N>(const U &) Broadcast a compound value to all elements (non-scalar element type).
function vec<T, N>::vec<T, N>(const value_type *, cbool_t<aligned>) Load from a memory location.
function vec<T, N>::vec<T, N>(const value_type &, const value_type &, const Us &...) Construct from two or more compound values (non-scalar element type).
constructor vec<T, N>::vec<T, N>(const vec<std::conditional_t<compound_type_traits<T>::is_scalar, bit<T>, T>, N> &) Construct a value vector from a mask of the same scalar type.
constructor vec<T, N>::vec<T, N>(const vec<T, N> &) Copy constructor.
function vec<T, N>::vec<T, N>(const vec<T, Ns> &...) Concatenate several vectors whose sizes sum to N .
function vec<T, N>::vec<T, N>(const vec<U, N> &) Promote from a vector of a different (possibly compound) type.
constructor vec<T, N>::vec<T, N>(const vec<unwrap_bit<T>, N> &) Construct a mask vector from a value vector of the same scalar type.
constructor vec<T, N>::vec<T, N>(czeros_t) Construct an all-zeros vector (tag constructor).
function vec<T, N>::vec<T, N>(from_lambda, Fn &&) Construct from a generator callable.
constructor vec<T, N>::vec<T, N>(vec<T, N> &&) Move constructor.
function vector_alignment(size_t) Return the alignment (next power of two of size ) for a vector of size bytes.
variable vector_capacity Total SIMD capacity (in elements) for type T on the native platform.
typedef vector_types_for_size_t Convenience alias for the type list produced by vector_types_for_size_t_impl.
class vector_types_for_size_t_impl<vec_tpl, T, csizes_t<sizes...>> Specialization that expands the size list into a ctypes_t of vector types.
class vector_types_for_size_t_impl<vec_tpl, T, sizes> Builds a type list of vector instantiations of vec_tpl for element type T over the test vector sizes.
variable vector_width SIMD vector width (in elements) for type T on the native platform.
variable vector_width_for SIMD vector width (in elements) for type T on the given CPU.
class vecvec_template<N1, N2> Alias template producing vec<vec<T, N1>, N2> for fixed N1 , N2 .
typedef vecx Convenience alias building nested vec types from a list of sizes.

W¶

function widen(const vec<T, Nout> &, TS) Identity overload of widen() for the Nout == input length case.
function widen(const vec<T, N> &, std::type_identity_t<T>) Widens x to length Nout by appending lanes set to newvalue.
variable compound_type_traits<kfr::vec_shape<T, N>>::width
variable compound_type_traits<kfr::vec<T, N>>::width
variable compound_type_traits<std::complex<T>>::width Number of immediate sub-elements (real and imaginary).
function wrap_bit_value(const T &) Pass-through overload of wrap_bit_value for non-bit types.
function wrap_bit_value(const unwrap_bit<T> &) Wraps a raw mask value into a bit<T> .
variable stride_pointer<T, groupsize>::writable_ptr
function write_group(T *, size_t, const vec<T, group * count * N> &) Writes count groups of group*N elements separated by stride groups.
function stride_pointer<T, groupsize>::write(const vec<T, N> &, csize_t<N>) Scatters N elements of val to the underlying pointer using the stored stride.
function write(T *, const vec<T, N> &) Writes a vector of N elements of type T to memory.
function vec<T, N>::write(value_type *, cbool_t<aligned>) Store to a memory location.

Z¶

function zeroize(T1 &) Fills a value with zeros
function zerovector() Return an all-zeros vector of the given type and size.
function zerovector(vec_shape<T, N>) Return an all-zeros vector matching the given shape.
function zerovector(vec<T, N>) Return an all-zeros vector matching the type of the given vector.
function zip(const vec<T, N1> &, const vec<T, Ns> &...) Zips multiple vectors into a vector of vectors.

This file was generated by cxxdox, a C++ documentation generator based on MkDocs Material and libclang.