std::simd::basic_vec, std::simd::simd

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

Memory management library

Metaprogramming library (C++11)

General utilities library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library (C++17)

Concurrency support library (C++11)

Execution control library (C++26)

Technical specifications

Symbols index

External libraries

 

Numerics library

Common mathematical functions
Mathematical special functions (C++17)
Mathematical constants (C++20)
Basic linear algebra algorithms (C++26)
Data-parallel types (SIMD) (C++26)
Floating-point environment (C++11)
Complex numbers
Numeric array (valarray)
Pseudo-random number generation
Bit manipulation (C++20)
Saturation arithmetic (C++26)
Factor operations
gcd (C++17)	lcm (C++17)
Interpolations
midpoint (C++20)	lerp (C++20)
Generic numeric operations
iota (C++11) ranges::iota (C++23) accumulate inner_product adjacent_difference      partial_sum	reduce (C++17) transform_reduce (C++17) inclusive_scan (C++17) exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)
C-style checked integer arithmetic
ckd_add (C++26) ckd_sub (C++26)	ckd_mul (C++26)

 

Data-parallel types (SIMD)

Main classes basic_vecvec basic_maskmask Load and store flags flagsflag_defaultflag_convertflag_alignedflag_overaligned      Load and store unchecked_loadpartial_load unchecked_storepartial_store Casts chunk cat

Algorithms minmaxminmax clamp select Reductions all_ofany_ofnone_of reducereduce_minreduce_max reduce_min_indexreduce_max_index reduce_count Traits alignment rebind resize

 

std::simd::basic_vec

Template:cpp/numeric/simd/basic vec/navbar content

 

Defined in header <simd>
template< class T, class Abi = /*native-abi*/<T> > class basic_vec;	(1)	(since C++26)
template< class T, /*simd-size-type*/ N = /*simd-size-v*/<T, /*native-abi*/<T>> > using simd = basic_vec<T, /*deduce-abi-t*/<T, N>>;	(2)	(since C++26)

1) std::simd::basic_vec specialization is a data-parallel type. The default ABI tag is determined by the implementation at compile-time.

2) std::simd::vec is an alias template that allows users to specify the width to a certain size. The default width is determined by the implementation at compile-time.

Every specialization of basic_vec is a complete type. The specialization is

• enabled, if T is a vectorizable type, and there exists value M in the range [1, 64] such that Abi is deduce-abi-t<T, M>,
• otherwise disabled, if T is not a vectorizable type,
• otherwise, it is implementation-defined if such specialization is enabled.

If basic_vec<T, Abi> is disabled, the specialization has all deleted default constructor, destructor, copy constructor, and copy assignment. In addition, only the member types below are present.

If basic_vec<T, Abi> is enabled, basic_vec<T, Abi> is TriviallyCopyable.

Template parameters

T	-	element type; a vectorizable type
Abi	-	tag type used to determine the width and storage
N	-	the width of the data-parallel type; the number of elements

Member types

Type	Definition
value_type	T
mask_type	simd::basic_mask<sizeof(T), Abi>
abi_type	Abi

Member constant

Name	Description
simd-size-type simd-size-v size [static]	the width of basic_vec (public static member constant)

Member functions

Template:cpp/numeric/simd/basic vec/dsc constructorTemplate:cpp/numeric/simd/basic vec/dsc operator atTemplate:cpp/numeric/simd/basic vec/dsc operator mem arithTemplate:cpp/numeric/simd/basic vec/dsc operator mem arith2

Non-member functions

Template:cpp/numeric/simd/basic vec/dsc operator arithTemplate:cpp/numeric/simd/basic vec/dsc operator compoundTemplate:cpp/numeric/simd/basic vec/dsc operator cmp Template:cpp/numeric/simd/basic vec/dsc simd select

Deduction guide

template< class R, class... Ts > basic_vec( R&& r, Ts... ) -> /* see below */;		(since C++26)

The deduction guide is present only if:

• R models contiguous_range and sized_range, and
• ranges::size(r) is a constant expression.

The deduced type is equivalent to simd::vec<ranges::range_value_t<R>, ranges::size(r)>.

Notes

Implementations are recommended to support explicit conversions between enabled specializations of basic_vec and appropriate implementation-defined types. These appropriate types are non-standard vector types which are available in the implementation.

See also

simd::basic_mask (C++26)	data-parallel type with the element type bool (class template)
simd::mask (C++26)	convenience alias template for basic_mask that can specify its width (alias template)
valarray	numeric arrays, array masks and array slices (class template)