Skip to content

shuffle

broadcast class (generic::fn::broadcast)

broadcast

padhigh class (generic::fn::padhigh)

padhigh

padlow class (generic::fn::padlow)

padlow

extend class (generic::fn::extend)

extend

slice class (generic::fn::slice)

slice

replace class (generic::fn::replace)

replace

split class (generic::fn::split)

split

part class (generic::fn::part)

part

concat_and_slice class (generic::fn::concat_and_slice)

concat_and_slice

widen class (generic::fn::widen)

widen

narrow class (generic::fn::narrow)

narrow

even class (generic::fn::even)

even

odd class (generic::fn::odd)

odd

dupeven class (generic::fn::dupeven)

dupeven

dupodd class (generic::fn::dupodd)

dupodd

duphalves class (generic::fn::duphalves)

duphalves

shuffle class (generic::fn::shuffle)

shuffle

shufflegroups class (generic::fn::shufflegroups)

shufflegroups

permute class (generic::fn::permute)

permute

permutegroups class (generic::fn::permutegroups)

permutegroups

generate_vector class (generic::fn::generate_vector)

generate_vector

dup class (generic::fn::dup)

dup

duplow class (generic::fn::duplow)

duplow

duphigh class (generic::fn::duphigh)

duphigh

blend class (generic::fn::blend)

blend

fn_swap class (generic::fn::fn_swap)

template <> fn_swap

rotateright class (generic::fn::rotateright)

rotateright

rotateleft class (generic::fn::rotateleft)

rotateleft

insertright class (generic::fn::insertright)

insertright

insertleft class (generic::fn::insertleft)

insertleft

transpose class (generic::fn::transpose)

transpose

transposeinverse class (generic::fn::transposeinverse)

transposeinverse

ctranspose class (generic::fn::ctranspose)

ctranspose

ctransposeinverse class (generic::fn::ctransposeinverse)

ctransposeinverse

interleave class (generic::fn::interleave)

interleave

zip class (generic::fn::zip)

zip

interleavehalves class (generic::fn::interleavehalves)

interleavehalves

splitpairs class (generic::fn::splitpairs)

splitpairs

reverse class (generic::fn::reverse)

reverse

combine class (generic::fn::combine)

combine

generate_index class (generic::internal::generate_index)

template <size_t start, size_t stride> generate_index

generate_onoff class (generic::internal::generate_onoff)

template <size_t start, size_t size, int on, int off>
generate_onoff

enumerate class (generic::fn::enumerate)

enumerate

onoff class (generic::fn::onoff)

onoff

shuffle_index_digitreverse class (generic::internal::shuffle_index_digitreverse)

template <size_t radix, size_t bits>
shuffle_index_digitreverse

digitreverse function (generic::digitreverse)

template <size_t radix, size_t group = 1, typename T,
          size_t N>
vec<T, N> digitreverse(const vec<T, N> &x)

Reorders the elements of a vector by reversing the digits of their indices in the specified radix.

Optionally groups elements before reversing.
Template param radix The numeric base used for digit reversal (2 or 4).
Template param group The grouping size; elements are grouped before index reversal.
Template param T The element type of the vector.
Template param N The number of elements in the vector.
Param x The input vector to be reordered.
Returns A vector with elements reordered based on digit-reversed indices.

bitreverse function (generic::bitreverse)

template <size_t groupsize = 1, typename T, size_t N>
vec<T, N> bitreverse(const vec<T, N> &x)

Reorders the elements of a vector by reversing the bits of their indices.

A specialization of digitreverse with radix 2 (binary). Optionally supports grouped bit reversal.
Template param groupsize Number of elements per group before applying bit reversal.
Template param T The element type of the vector.
Template param N The number of elements in the vector.
Param x The input vector to be reordered.
Returns A vector with bit-reversed indices.

digitreverse4 function (generic::digitreverse4)

template <size_t groupsize = 1, typename T, size_t N>
vec<T, N> digitreverse4(const vec<T, N> &x)

Reorders the elements of a vector by reversing base-4 (quaternary) digits of their indices.

Similar to bitreverse, but uses radix 4 for digit reversal.
Template param groupsize Number of elements per group before applying reversal.
Template param T The element type of the vector.
Template param N The number of elements in the vector.
Param x The input vector to be reordered.
Returns A vector with base-4 digit-reversed indices.

bitreverse function (generic::bitreverse)

template <size_t bits> constexpr u32 bitreverse(u32 x)

Reverses the lowest bits bits of the given unsigned integer.
Template param bits Number of bits to reverse.
Param x The input 32-bit unsigned integer.
Returns The bit-reversed integer.

digitreverse4 function (generic::digitreverse4)

template <size_t bits> constexpr u32 digitreverse4(u32 x)

Reverses the digits of the given unsigned integer in base-4 (quaternary), using the lowest bits digits.

Useful for radix-4 FFT or similar algorithms.
Template param bits Number of base-4 digits to reverse.
Param x The input 32-bit unsigned integer.
Returns The base-4 digit-reversed integer.

Auto-generated from sources, Revision , https://github.com/kfrlib/kfr/blob//include/kfr/