Skip to content

Class vec

class vec<T, N> simd

template <typename T, size_t N>
struct alignas(internal::vec_alignment<T, N>) vec { … }

SIMD vector type of T elements with default width vector_width .

Template parameters
T The element type.
N The vector width in elements (defaults to vector_width ).

function shape() 

static constexpr vec_shape<T, N> shape() noexcept { … }

Returns
A vec_shape describing this vector's type and size.

Fully qualified name: kfr::vec<T, N>::shape()

Declared at simd/vec.hpp:312

typedef value_type 

using value_type = T

Fully qualified name: kfr::vec<T, N>::value_type

Declared at simd/vec.hpp:314

function size() 

constexpr static size_t size() noexcept { … }

Returns
Number of top-level elements.

Fully qualified name: kfr::vec<T, N>::size()

Declared at simd/vec.hpp:317

typedef ST 

using ST          = typename compound_type_traits<T>::deep_subtype

Fully qualified name: kfr::vec<T, N>::ST

Declared at simd/vec.hpp:319

typedef scalar_type 

using scalar_type = ST

Fully qualified name: kfr::vec<T, N>::scalar_type

Declared at simd/vec.hpp:320

variable SW 

constexpr static inline size_t SW =
    compound_type_traits<T>::deep_width

Fully qualified name: kfr::vec<T, N>::SW

Declared at simd/vec.hpp:322

variable SN 

constexpr static inline size_t SN = N * SW

Total scalar count.

Fully qualified name: kfr::vec<T, N>::SN

Declared at simd/vec.hpp:324

function scalar_size() 

constexpr static size_t scalar_size() noexcept { … }

Returns
Total number of scalar elements ( N * SW ).

Fully qualified name: kfr::vec<T, N>::scalar_size()

Declared at simd/vec.hpp:327

typedef mask_t 

using mask_t = mask<T, N>

Fully qualified name: kfr::vec<T, N>::mask_t

Declared at simd/vec.hpp:334

typedef simd_type 

using simd_type   = intr::simd<ST, SN>

Fully qualified name: kfr::vec<T, N>::simd_type

Declared at simd/vec.hpp:336

typedef uvalue_type 

using uvalue_type = utype<T>

Fully qualified name: kfr::vec<T, N>::uvalue_type

Declared at simd/vec.hpp:337

typedef iuvalue_type 

using iuvalue_type =
    std::conditional_t<is_i_class<T>, T, uvalue_type>

Fully qualified name: kfr::vec<T, N>::iuvalue_type

Declared at simd/vec.hpp:338

typedef uscalar_type 

using uscalar_type = utype<ST>

Fully qualified name: kfr::vec<T, N>::uscalar_type

Declared at simd/vec.hpp:341

typedef iuscalar_type 

using iuscalar_type =
    std::conditional_t<is_i_class<ST>, ST, uscalar_type>

Fully qualified name: kfr::vec<T, N>::iuscalar_type

Declared at simd/vec.hpp:342

typedef usimd_type 

using usimd_type  = intr::simd<uscalar_type, SN>

Fully qualified name: kfr::vec<T, N>::usimd_type

Declared at simd/vec.hpp:345

typedef iusimd_type 

using iusimd_type = intr::simd<iuscalar_type, SN>

Fully qualified name: kfr::vec<T, N>::iusimd_type

Declared at simd/vec.hpp:346

constructor vec<T, N>(const simd_type &)

Construct from a native SIMD register.

Fully qualified name: kfr::vec<T, N>::vec<T, N>(const simd_type &)

Declared at simd/vec.hpp:349

constructor vec<T, N>()

Default constructor (elements are left uninitialized).

Fully qualified name: kfr::vec<T, N>::vec<T, N>()

Declared at simd/vec.hpp:351

constructor vec<T, N>(const vec<T, N> &)

Copy constructor.

Fully qualified name: kfr::vec<T, N>::vec<T, N>(const vec<T, N> &)

Declared at simd/vec.hpp:373

constructor vec<T, N>(vec<T, N> &&)

Move constructor.

Fully qualified name: kfr::vec<T, N>::vec<T, N>(vec<T, N> &&)

Declared at simd/vec.hpp:375

function operator=(const vec<T, N> &)

Copy assignment operator.

Fully qualified name: kfr::vec<T, N>::operator=(const vec<T, N> &)

Declared at simd/vec.hpp:377

function operator=(vec<T, N> &&)

Move assignment operator.

Fully qualified name: kfr::vec<T, N>::operator=(vec<T, N> &&)

Declared at simd/vec.hpp:379

function vec<T, N>(const U &) 

template <typename U>
    requires(std::is_convertible_v<U, value_type> && !compound_type_traits<T>::is_scalar)
KFR_MEM_INTRINSIC vec(const U& s) noexcept

Broadcast a compound value to all elements (non-scalar element type).

Fully qualified name: kfr::vec<T, N>::vec<T, N>(const U &)

Declared at simd/vec.hpp:393

function vec<T, N>(const value_type &, const value_type &, const Us &...) 

template <typename... Us>
    requires(sizeof...(Us) <= 1022 && !compound_type_traits<T>::is_scalar)
KFR_MEM_INTRINSIC vec(const value_type& s0, const value_type& s1, const Us&... rest) noexcept

Construct from two or more compound values (non-scalar element type).

Fully qualified name: kfr::vec<T, N>::vec<T, N>(const value_type &, const value_type &, const Us &...)

Declared at simd/vec.hpp:411

function vec<T, N>(const vec<U, N> &) 

template <std::convertible_to<value_type> U>
    requires(!(compound_type_traits<T>::is_scalar && !is_bit<U>))
KFR_MEM_INTRINSIC vec(const vec<U, N>& x) noexcept

Promote from a vector of a different (possibly compound) type.

Fully qualified name: kfr::vec<T, N>::vec<T, N>(const vec<U, N> &)

Declared at simd/vec.hpp:459

constructor 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.

Fully qualified name: kfr::vec<T, N>::vec<T, N>(const vec<std::conditional_t<compound_type_traits<T>::is_scalar, bit<T>, T>, N> &)

Declared at simd/vec.hpp:427

constructor vec<T, N>(const vec<unwrap_bit<T>, N> &)

Construct a mask vector from a value vector of the same scalar type.

Fully qualified name: kfr::vec<T, N>::vec<T, N>(const vec<unwrap_bit<T>, N> &)

Declared at simd/vec.hpp:435

function vec<T, N>(from_lambda, Fn &&) 

template <typename Fn>
    requires(std::is_invocable_r_v<T, Fn, size_t>)
KFR_MEM_INTRINSIC vec(from_lambda, Fn&& fn) noexcept

Construct from a generator callable.

Parameters
fn Invocable as T(size_t) ; element i is initialized to fn(i) .

Fully qualified name: kfr::vec<T, N>::vec<T, N>(from_lambda, Fn &&)

Declared at simd/vec.hpp:447

function vec<T, N>(const vec<T, Ns> &...) 

template <size_t... Ns>
    requires((Ns + ...) == N)
KFR_MEM_INTRINSIC vec(const vec<T, Ns>&... vs) noexcept

Concatenate several vectors whose sizes sum to N .

Fully qualified name: kfr::vec<T, N>::vec<T, N>(const vec<T, Ns> &...)

Declared at simd/vec.hpp:469

constructor vec<T, N>(const portable_vec<T, N> &)

Reinterpret a portable_vec as a vec (layout-compatible).

Fully qualified name: kfr::vec<T, N>::vec<T, N>(const portable_vec<T, N> &)

Declared at simd/vec.hpp:474

operator operator portable_vec<type-parameter-0-0, value-parameter-0-1>()

Convert to a layout-compatible portable_vec .

Fully qualified name: kfr::vec<T, N>::operator portable_vec<type-parameter-0-0, value-parameter-0-1>()

Declared at simd/vec.hpp:477

constructor vec<T, N>(czeros_t)

Construct an all-zeros vector (tag constructor).

Fully qualified name: kfr::vec<T, N>::vec<T, N>(czeros_t)

Declared at simd/vec.hpp:483

constructor vec<T, N>(cones_t)

Construct an all-ones vector (tag constructor).

Fully qualified name: kfr::vec<T, N>::vec<T, N>(cones_t)

Declared at simd/vec.hpp:486

function frombits(const vec<U, M> &) 

template <typename U, size_t M>
    requires(sizeof(U) * M == sizeof(T) * N)
KFR_MEM_INTRINSIC static vec frombits(const vec<U, M>& v) noexcept

Reinterpret the bits of v as a vector of this type.

Template parameters
U Source element type.
M Source element count; sizeof(U)*M must equal sizeof(T)*N .

Fully qualified name: kfr::vec<T, N>::frombits(const vec<U, M> &)

Declared at simd/vec.hpp:495

function shuffle(csizes_t<indices...>) 

template <size_t... indices>
KFR_MEM_INTRINSIC vec<value_type, sizeof...(indices)> shuffle(csizes_t<indices...> i) const noexcept

Permute elements of this vector according to i .

Parameters
i Compile-time index list; element j of the result is (*this)[i[j]] .
Returns
A vector of size sizeof...(indices) .

Fully qualified name: kfr::vec<T, N>::shuffle(csizes_t<indices...>)

Declared at simd/vec.hpp:507

function shuffle(const vec<T, N> &, csizes_t<indices...>) 

template <size_t... indices>
KFR_MEM_INTRINSIC vec<value_type, sizeof...(indices)> shuffle(const vec& y,
                                                              csizes_t<indices...> i) const noexcept

Permute elements from two concatenated vectors (*this, y) .

Parameters
y Second source vector.
i Compile-time index list selecting from [0, 2N) .

Fully qualified name: kfr::vec<T, N>::shuffle(const vec<T, N> &, csizes_t<indices...>)

Declared at simd/vec.hpp:540

struct element 

struct element { … }

Proxy reference to a single vector element enabling read/write access.

operator operator type-parameter-0-0() 

constexpr operator value_type() const noexcept { … }

Read the referenced element.

Fully qualified name: kfr::vec<T, N>::element::operator type-parameter-0-0()

Declared at simd/vec.hpp:696

function operator[](size_t) 

template <typename U = T>
    requires(is_vec<U>)
KFR_MEM_INTRINSIC typename U::value_type operator[](size_t index) noexcept

Index into a compound element (nested vector).

Fully qualified name: kfr::vec<T, N>::element::operator[](size_t)

Declared at simd/vec.hpp:701

function operator+()

Unary plus (returns the value).

Fully qualified name: kfr::vec<T, N>::element::operator+()

Declared at simd/vec.hpp:706

function operator-()

Unary negation.

Fully qualified name: kfr::vec<T, N>::element::operator-()

Declared at simd/vec.hpp:708

function operator=(const value_type &)

Assign a scalar to the referenced element.

Fully qualified name: kfr::vec<T, N>::element::operator=(const value_type &)

Declared at simd/vec.hpp:711

function operator+=(const value_type &)

Add-assign a scalar.

Fully qualified name: kfr::vec<T, N>::element::operator+=(const value_type &)

Declared at simd/vec.hpp:718

function operator-=(const value_type &)

Subtract-assign a scalar.

Fully qualified name: kfr::vec<T, N>::element::operator-=(const value_type &)

Declared at simd/vec.hpp:724

function operator*=(const value_type &)

Multiply-assign a scalar.

Fully qualified name: kfr::vec<T, N>::element::operator*=(const value_type &)

Declared at simd/vec.hpp:730

function operator/=(const value_type &)

Divide-assign a scalar.

Fully qualified name: kfr::vec<T, N>::element::operator/=(const value_type &)

Declared at simd/vec.hpp:736

function operator++()

Pre-increment.

Fully qualified name: kfr::vec<T, N>::element::operator++()

Declared at simd/vec.hpp:742

function operator--()

Pre-decrement.

Fully qualified name: kfr::vec<T, N>::element::operator--()

Declared at simd/vec.hpp:748

function operator++(int)

Post-increment.

Fully qualified name: kfr::vec<T, N>::element::operator++(int)

Declared at simd/vec.hpp:754

function operator--(int)

Post-decrement.

Fully qualified name: kfr::vec<T, N>::element::operator--(int)

Declared at simd/vec.hpp:761

function operator=(const element &)

Copy-assign from another element proxy.

Fully qualified name: kfr::vec<T, N>::element::operator=(const element &)

Declared at simd/vec.hpp:769

function operator=(const typename vec<U, M>::element &) 

template <typename U, size_t M>
KFR_MEM_INTRINSIC element& operator=(const typename vec<U, M>::element& s) noexcept

Assign from an element proxy of a different vector type.

Fully qualified name: kfr::vec<T, N>::element::operator=(const typename vec<U, M>::element &)

Declared at simd/vec.hpp:777

variable v 

vec& v

Owning vector.

Fully qualified name: kfr::vec<T, N>::element::v

Declared at simd/vec.hpp:783

variable index 

size_t index

Element index within

v .

Fully qualified name: kfr::vec<T, N>::element::index

Declared at simd/vec.hpp:784

Fully qualified name: kfr::vec<T, N>::element

Declared at simd/vec.hpp:693

function operator[](size_t)

Read element at index from a const lvalue vector.

Returns
A copy of the element at index .

Fully qualified name: kfr::vec<T, N>::operator[](size_t)

Declared at simd/vec.hpp:553

function operator[](size_t)

Read element at index from an rvalue vector.

Returns
A copy of the element at index .

Fully qualified name: kfr::vec<T, N>::operator[](size_t)

Declared at simd/vec.hpp:559

function operator[](size_t)

Access element at index from a non-const lvalue vector.

Returns
A mutable element proxy referencing element index of *this .

Fully qualified name: kfr::vec<T, N>::operator[](size_t)

Declared at simd/vec.hpp:565

function front()

Read the first element from a const lvalue vector.

Returns
A copy of element 0.

Fully qualified name: kfr::vec<T, N>::front()

Declared at simd/vec.hpp:571

function back()

Read the last element from a const lvalue vector.

Returns
A copy of element N - 1 .

Fully qualified name: kfr::vec<T, N>::back()

Declared at simd/vec.hpp:577

function front()

Read the first element from an rvalue vector.

Returns
A copy of element 0.

Fully qualified name: kfr::vec<T, N>::front()

Declared at simd/vec.hpp:583

function back()

Read the last element from an rvalue vector.

Returns
A copy of element N - 1 .

Fully qualified name: kfr::vec<T, N>::back()

Declared at simd/vec.hpp:589

function front()

Access the first element of a non-const lvalue vector.

Returns
A mutable element proxy referencing element 0 of *this .

Fully qualified name: kfr::vec<T, N>::front()

Declared at simd/vec.hpp:595

function back()

Access the last element of a non-const lvalue vector.

Returns
A mutable element proxy referencing element N - 1 of *this .

Fully qualified name: kfr::vec<T, N>::back()

Declared at simd/vec.hpp:601

function get(size_t)

Get element at runtime index (compound element type).

Fully qualified name: kfr::vec<T, N>::get(size_t)

Declared at simd/vec.hpp:611

function get(csize_t<index>) 

template <size_t index>
    requires(index < 1024 && !compound_type_traits<T>::is_scalar)
KFR_MEM_INTRINSIC constexpr value_type get(csize_t<index>) const noexcept { … }

Get element at compile-time index (compound element type).

Fully qualified name: kfr::vec<T, N>::get(csize_t<index>)

Declared at simd/vec.hpp:635

function get() 

template <size_t index>
KFR_MEM_INTRINSIC constexpr value_type get() const noexcept { … }

Get element at compile-time index (template parameter form).

Fully qualified name: kfr::vec<T, N>::get()

Declared at simd/vec.hpp:643

function set(size_t, const value_type &)

Set element at runtime index (compound element type).

Fully qualified name: kfr::vec<T, N>::set(size_t, const value_type &)

Declared at simd/vec.hpp:658

function set(csize_t<index>, const value_type &) 

template <size_t index>
    requires(index < 1024 && !compound_type_traits<T>::is_scalar)
KFR_MEM_INTRINSIC constexpr void set(csize_t<index>, const value_type& s) noexcept { … }

Set element at compile-time index (compound element type).

Fully qualified name: kfr::vec<T, N>::set(csize_t<index>, const value_type &)

Declared at simd/vec.hpp:681

function vec<T, N>(const value_type *, cbool_t<aligned>) 

template <bool aligned>
KFR_MEM_INTRINSIC constexpr vec<T, N>::vec(const value_type* src, cbool_t<aligned>) noexcept
    : vec(vec<T, N>::from_flatten(intr::read(cbool<aligned>, csize<N * compound_type_traits<T>::deep_width>,
                                             ptr_cast<deep_subtype<T>>(src)))) { … }

Load from a memory location.

Template parameters
aligned If true , src must be aligned to the vector alignment.
Parameters
src Pointer to N contiguous values.

Fully qualified name: kfr::vec<T, N>::vec<T, N>(const value_type *, cbool_t<aligned>)

Declared at simd/read_write.hpp:639

function write(value_type *, cbool_t<aligned>) 

template <bool aligned>
KFR_MEM_INTRINSIC const vec<T, N>& vec<T, N>::write(value_type* dest, cbool_t<aligned>) const noexcept

Store to a memory location.

Template parameters
aligned If true , dest must be aligned to the vector alignment.
Parameters
dest Pointer to N writable slots.
Returns
*this .

Fully qualified name: kfr::vec<T, N>::write(value_type *, cbool_t<aligned>)

Declared at simd/read_write.hpp:655

function flatten()

Returns
A flat vector of all scalar elements.

Fully qualified name: kfr::vec<T, N>::flatten()

Declared at simd/vec.hpp:807

function from_flatten(const vec<ST, SN> &)

Reconstruct a (possibly compound) vector from a flat scalar vector.

Fully qualified name: kfr::vec<T, N>::from_flatten(const vec<ST, SN> &)

Declared at simd/vec.hpp:810

function asmask()

Reinterpret the bits as a mask of the same shape.

Fully qualified name: kfr::vec<T, N>::asmask()

Declared at simd/vec.hpp:813

function asvec()

Reinterpret a mask vector as a value vector (drops the bit wrapper).

Fully qualified name: kfr::vec<T, N>::asvec()

Declared at simd/vec.hpp:820

variable simd_element_size 

constexpr static size_t simd_element_size =
    std::min(vector_width<T>, N)

Fully qualified name: kfr::vec<T, N>::simd_element_size

Declared at simd/vec.hpp:825

variable simd_element_count 

constexpr static size_t simd_element_count = N / simd_element_size

Number of native lanes.

Fully qualified name: kfr::vec<T, N>::simd_element_count

Declared at simd/vec.hpp:827

typedef simd_element_type 

using simd_element_type                    = simd<ST, simd_element_size>

Fully qualified name: kfr::vec<T, N>::simd_element_type

Declared at simd/vec.hpp:828

union (Anonymous union at simd/vec.hpp:831:5) 

union { … }

variable v 

simd_type v

Fully qualified name: kfr::vec<T, N>::(Anonymous union at simd/vec.hpp:831:5)::v

Declared at simd/vec.hpp:833

variable h 

vec_halves<T, N> h

Fully qualified name: kfr::vec<T, N>::(Anonymous union at simd/vec.hpp:831:5)::h

Declared at simd/vec.hpp:834

Fully qualified name: kfr::vec<T, N>::(Anonymous union at simd/vec.hpp:831:5)

Declared at simd/vec.hpp:831

Fully qualified name: kfr::vec<T, N>

Declared at simd/vec.hpp:309

Class vec

class vec<T, 0> simd

template <typename T>
struct vec<T, 0> { … }

Rejected specialization for zero-sized vectors.

Template parameters
T Element type (ignored).

Fully qualified name: kfr::vec<T, 0>

Declared at simd/vec.hpp:289

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