std::experimental::split, split_by

 

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)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Execution support library (C++26)

Technical specifications

Symbols index

External libraries

 

Experimental

Technical Specification

Filesystem library (filesystem TS)

Library fundamentals (library fundamentals TS)

Library fundamentals 2 (library fundamentals TS v2)

Library fundamentals 3 (library fundamentals TS v3)

Extensions for parallelism (parallelism TS)

Extensions for parallelism 2 (parallelism TS v2)

Extensions for concurrency (concurrency TS)

Extensions for concurrency 2 (concurrency TS v2)

Concepts (concepts TS)

Ranges (ranges TS)

Reflection (reflection TS)

Mathematical special functions (special functions TR)

Experimental Non-TS

Pattern Matching

Linear Algebra

std::execution

Contracts

2D Graphics

 

Extensions for parallelism v2

Parallel exceptions
exception_list
Additional execution policies
execution::vector_policy	execution::unsequenced_policy
Algorithms
induction reductionreduction_plusreduction_minusreduction_multiplies	reduction_bit_andreduction_bit_orreduction_bit_xorreduction_minreduction_max	for_loopfor_loop_stridedfor_loop_nfor_loop_n_strided
execution::no_vec
execution::ordered_update_t
Task blocks
task_block
task_cancelled_exception
define_task_blockdefine_task_block_restore_thread
Data-parallel vectors

 

SIMD library

Main classes
simd	simd_mask
ABI tags
simd_abi::scalar simd_abi::fixed_size	simd_abi::native simd_abi::compatible	simd_abi::max_fixed_size simd_abi::deduce
Alignment tags
element_aligned_tagelement_aligned	vector_aligned_tagvector_aligned	overaligned_tagoveraligned
Where expression
where	where_expression	const_where_expression
Casts
simd_caststatic_simd_cast	to_fixed_sizeto_compatibleto_native	splitsplit_by concat
Algorithms
min max	minmax clamp
Reduction
reducehminhmax
Mask reduction
all_ofany_ofnone_ofsome_of	popcount find_first_setfind_last_set
Traits
is_simdis_simd_mask is_abi_tag is_simd_flag_type	simd_size memory_alignment rebind_simdresize_simd
Math functions

 

Defined in header <experimental/simd>
template< std::size_t... Sizes, class T, class Abi > std::tuple<simd<T, simd_abi::deduce_t<T, Sizes>>...>     split( const simd<T, Abi>& v ) noexcept;	(1)	(parallelism TS v2)
template< std::size_t... Sizes, class T, class Abi > std::tuple<simd_mask<T, simd_abi::deduce_t<T, Sizes>>...>     split( const simd_mask<T, Abi>& v ) noexcept;	(2)	(parallelism TS v2)
template< class V, class Abi > std::array<V, simd_size_v<typename V::value_type, Abi> / V::size()>     split( const simd<typename V::value_type, Abi>& v ) noexcept;	(3)	(parallelism TS v2)
template< class V, class Abi > std::array<V, simd_size_v<typename V::value_type, Abi> / V::size()>     split( const simd_mask<typename V::value_type, Abi>& v ) noexcept;	(4)	(parallelism TS v2)
template< size_t N, class T, class A > array<resize_simd<simd_size_v<T, A> / N, simd<T, A>>, N>     split_by( const simd<T, A>& v ) noexcept;	(5)	(parallelism TS v2)
template< size_t N, class T, class A > array<resize_simd<simd_size_v<T, A> / N, simd_mask<T, A>>, N>     split_by( const simd_mask<T, A>& v ) noexcept;	(6)	(parallelism TS v2)

Splits the input simd or simd_mask object into multiple simd or simd_mask objects.

1,2) Split the input object into potentially different types (e.g. types with different sizes) of objects. These functions do not participate in overloading resolution unless Sizes... sum up to v.size().

3,4) Split the input object into an array of objects. These functions do not participate in overloading resolution unless

• The array element must be of type simd or simd_mask, for the type of v as simd or simd_mask, respectively.
• simd_size_v<typename V::value_type, Abi> is an integral multiple of V::size().

5,6) Split the input object into an array of objects. These functions shall not participate in overload resolution unless simd_size_v<T, A> is an integral multiple of N.

Parameters

v

-

the input simd or simd_mask object

Return value

1,2) A tuple that contains the splitted simd or simd_mask objects.

3-6) An array that contains the splitted simd or simd_mask objects.