xsimd

https://xsimd.readthedocs.io/en/latest/
Admin
xsimd is a C++ library providing high-level wrappers for SIMD intrinsics, enabling portable and...
Tokens:82,461
Snippets:697
Trust Score:8.3
Update:1 day ago
Show doc for...
Tokens:
Raw
### Install xsimd from source with CMake

Source: https://xsimd.readthedocs.io/en/latest/installation.html

Configures, builds, and installs xsimd from source using CMake, with a custom install prefix.

```bash
cmake -B build/ -D CMAKE_INSTALL_PREFIX=/path/to/install/dir
cmake --build build/
cmake --install build/
```

--------------------------------

### Install xsimd with Spack

Source: https://xsimd.readthedocs.io/en/latest/installation.html

Installs and loads the xsimd package using the Spack package manager.

```bash
spack install xsimd
spack load xsimd
```

--------------------------------

### Install xsimd from source with CMake using NMake generator

Source: https://xsimd.readthedocs.io/en/latest/installation.html

Configures, builds, and installs xsimd from source using CMake with the NMake Makefiles generator, useful on Windows platforms.

```bash
cmake -B build/ -G "NMake Makefiles" -D CMAKE_INSTALL_PREFIX=/path/to/install/dir
cmake --build build/
cmake --install build/
```

--------------------------------

### Install xsimd with mamba/conda

Source: https://xsimd.readthedocs.io/en/latest/installation.html

Installs the xsimd package from the conda-forge channel using the mamba (or conda) package manager.

```bash
mamba install -c conda-forge xsimd
```

--------------------------------

### xsimd::common::name

Source: https://xsimd.readthedocs.io/en/latest/api/arch.html

Static function to get the name of the architecture.

```APIDOC
## [STATIC] xsimd::common::name()

### Description
Name of the architecture.

### Method
static inline constexpr char const *name() noexcept

### Parameters
None

### Returns
- **const char*** - The name of the architecture.

```

--------------------------------

### Enable xtl complex support in CMake

Source: https://xsimd.readthedocs.io/en/latest/build_options.html

Sets an option to enable xtl complex support and finds the xsimd package. This links the xtl library and adds the macro definition to xsimd's interface. Requires xtl to be installed and in the project include directories.

```cmake
option(XSIMD_ENABLE_XTL_COMPLEX "Enable xtl complex support" ON)
find_package(xsimd REQUIRED)
```

--------------------------------

### load_as (aligned)

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Creates a batch from the buffer ptr and the specified batch value type To. The memory needs to be aligned.

```APIDOC
## load_as (aligned)

### Description
Creates a batch from the buffer `ptr` and the specified batch value type `To`. The memory needs to be aligned.

### Method
Function template

### Signature
```cpp
template<class To, class A = default_arch, class From>
inline simd_return_type<From, To, A> load_as(From const *ptr, aligned_mode) noexcept;
```

### Parameters
- **ptr** (From const*) - The memory buffer to read.

### Returns
A new batch instance.
```

--------------------------------

### batch_constant::get

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch_constant.html

Gets the i-th element of this batch_constant.

```APIDOC
## batch_constant::get

### Description
Gets the `i`-th element of this `batch_constant`.

### Method
get(i)

### Signature
`inline constexpr T get(std::size_t i) const noexcept`

### Parameters
- **i** (std::size_t) - Required - Index of the element to retrieve.

### Returns
- **T** - The value of the `i`-th constant.

```

--------------------------------

### batch()

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch.html

Default constructor that creates a batch initialized with undefined values.

```APIDOC
## batch()

### Description
Create a batch initialized with undefined values.

### Method
Constructor

### Signature
```cpp
inline batch() = default
```

### Parameters
None.

### Returns
A batch object with undefined values.
```

--------------------------------

### xsimd::common::available

Source: https://xsimd.readthedocs.io/en/latest/api/arch.html

Static function to check if the architecture is available at run-time.

```APIDOC
## [STATIC] xsimd::common::available()

### Description
Whether this architecture is available at run-time.

### Method
static inline constexpr bool available() noexcept

### Parameters
None

### Returns
- **bool** - True if the architecture is available at run-time.

```

--------------------------------

### get

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Extracts the scalar element at compile-time index I from a batch.

```APIDOC
## get

### Description
Extracts the scalar element at compile-time index `I` from batch `b`.

### Method
Function template

### Signature
```cpp
template<size_t I, class T, class A>
inline T get(batch<T, A> const &b) noexcept;
```

### Parameters
- **b** (batch<T, A>) - The batch to extract from.

### Returns
The scalar element at index `I`.
```

--------------------------------

### get(std::size_t i)

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch.html

Retrieves the i-th scalar element in this batch.

```APIDOC
## get(std::size_t i)

### Description
Retrieve the `i` th scalar element in this batch.

### Method
`get`

### Signature
`inline T get(std::size_t i) const noexcept`

### Parameters
- `i` (std::size_t) - Index of the element to retrieve.

### Returns
- `T` - The scalar element at index `i`.

```

--------------------------------

### Enable emulated architecture with XSIMD_WITH_EMULATED in CMake

Source: https://xsimd.readthedocs.io/en/latest/build_options.html

Adds a compile definition to enable the emulated architecture. Set XSIMD_WITH_EMULATED to 1 to exhibit an emulated architecture.

```cmake
target_add_compile_definitions(myproject PRIVATE XSIMD_WITH_EMULATED=1)
```

--------------------------------

### load (aligned)

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Creates a batch from an aligned memory buffer. The memory must be aligned.

```APIDOC
## load (aligned)

### Description
Creates a batch from the buffer `ptr`. The memory needs to be aligned.

### Function Signature
```cpp
template<class A = default_arch, class From>
inline batch<From, A> load(From const *ptr, aligned_mode = {}) noexcept
```

### Parameters
- **ptr** (const From*) - Required - The memory buffer to read.

### Returns
A new batch instance.
```

--------------------------------

### xsimd::common::alignment

Source: https://xsimd.readthedocs.io/en/latest/api/arch.html

Static function to get the required alignment for aligned memory accesses.

```APIDOC
## [STATIC] xsimd::common::alignment()

### Description
If this architecture supports aligned memory accesses, the required alignment.

### Method
static inline constexpr std::size_t alignment() noexcept

### Parameters
None

### Returns
- **std::size_t** - The required alignment in bytes.

```

--------------------------------

### load (masked, compile-time)

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Creates a batch from a buffer using a compile-time mask. Elements corresponding to false in the mask are not accessed and are zero-initialized.

```APIDOC
## load (masked, compile-time)

### Description
Creates a batch from the buffer `ptr` using a mask. Elements corresponding to `false` in the mask are not accessed in memory and are zero-initialized in the resulting batch.

### Function Signature
```cpp
template<class T, class A = default_arch, bool... Values, class From>
inline batch<T, A> load(From const *ptr, batch_bool_constant<T, A, Values...> const &mask, aligned_mode = {}) noexcept
```

### Parameters
- **ptr** (const From*) - Required - The memory buffer to read.
- **mask** (batch_bool_constant<T, A, Values...> const&) - Required - Selection mask for the elements to load.

### Returns
A new batch instance.
```

--------------------------------

### scatter(U* dst, batch<V, arch_type> const& index)

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch.html

Scatters elements from this batch into addresses starting at `dst` and offset by each element in `index`.

```APIDOC
## scatter(U* dst, batch<V, arch_type> const& index)

### Description
Scatter elements from this batch into addresses starting at `dst` and offset by each element in `index`. If `T` is not of the same size as `U`, a `static_cast` is performed at element scatter time.

### Method
`scatter`

### Signature
`template<class U, class V> inline void scatter(U* dst, batch<V, arch_type> const& index) const noexcept`

### Parameters
- `dst` (U*) - Base address for scattering.
- `index` (batch<V, arch_type> const&) - Batch of indices used to offset from `dst`.

```

--------------------------------

### load (masked, runtime)

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Creates a batch from a buffer using a runtime mask. Elements corresponding to false in the mask are not accessed and are zero-initialized. No type conversion is performed.

```APIDOC
## load (masked, runtime)

### Description
Creates a batch from the buffer `ptr` using a runtime mask. Elements corresponding to `false` in the mask are not accessed in memory and are zero-initialized in the resulting batch. No type conversion is performed: `ptr` must point to `T`. Prefer the `batch_bool_constant` overload whenever the mask is known at compile time.

### Function Signature
```cpp
template<class T, class A = default_arch>
inline batch<T, A> load(T const *ptr, batch_bool<T, A> mask, aligned_mode = {}) noexcept
```

### Parameters
- **ptr** (const T*) - Required - The memory buffer to read.
- **mask** (batch_bool<T, A>) - Required - Runtime mask for the elements to load.

### Returns
A new batch instance.
```

--------------------------------

### batch(T val0, T val1, Ts... vals)

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch.html

Constructor that creates a batch with elements initialized from the provided values. There must be exactly `size` elements in total.

```APIDOC
## batch(T val0, T val1, Ts... vals)

### Description
Create a batch with elements initialized from `val0`, `val1`, `vals`… There must be exactly `size` elements in total.

### Method
Constructor

### Signature
```cpp
template<class ...Ts>
inline batch(T val0, T val1, Ts... vals) noexcept
```

### Parameters
- **val0** (T) - Required - The first element value.
- **val1** (T) - Required - The second element value.
- **vals** (Ts...) - Required - Additional element values. The total number of elements must equal `size`.

### Returns
A batch object with elements initialized from the provided values.
```

--------------------------------

### scatter

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch_complex.html

Scatters elements from this batch into memory addresses starting at dst, with offsets provided by the index batch. A static_cast is performed if T and U differ in size.

```APIDOC
## scatter

### Description
Scatters elements from this batch into memory addresses starting at `dst`, with offsets provided by the `index` batch. A `static_cast` is performed if `T` and `U` differ in size.

### Method
`scatter`

### Signature
`inline void scatter(U *dst, batch<V, arch_type> const &index) const noexcept`

### Parameters
- **dst** (U*) - Pointer to the destination memory.
- **index** (batch<V, arch_type> const&) - Batch of offsets used to scatter elements.

### Return Value
None (void).
```

--------------------------------

### Invoking mean with alignment tag

Source: https://xsimd.readthedocs.io/en/latest/vectorized_code.html

Example call to the mean function using a get_alignment_tag meta-function to obtain the appropriate alignment tag for the container type.

```cpp
mean(a, b, res, get_alignment_tag<decltype(a)>());
```

--------------------------------

### store_as (aligned)

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Copies the content of a batch to a memory buffer. The memory must be aligned.

```APIDOC
## store_as (aligned)

### Description
Copies the content of batch `src` to the buffer `dst`. The memory needs to be aligned.

### Template Parameters
- **To** - Type of the destination buffer.
- **A** (default_arch) - Architecture.
- **From** - Type of the source batch.

### Parameters
- **dst** (To*) - The memory buffer to write to.
- **src** (batch<From, A>) - The batch to copy.
- **aligned_mode** - Alignment mode indicator.
```

--------------------------------

### load_as()

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Loads values from memory, forcing a type conversion.

```APIDOC
## load_as()

### Description
Loads values from memory, forcing a type conversion.

### Signature
`simd_return_type<From, To, A> load_as(const From* mem, aligned_mode)`

### Parameters
- `mem` (const From*) - Pointer to the memory to load from.
- `mode` (aligned_mode) - Alignment mode.

### Returns
A batch with the converted type.
```

--------------------------------

### gather

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch_complex.html

Creates a new batch by gathering elements from memory starting at address src, with offsets provided by the index batch. A static_cast is performed if T and U differ in size.

```APIDOC
## gather

### Description
Creates a new batch by gathering elements from memory starting at address `src`, with offsets provided by the `index` batch. A `static_cast` is performed if `T` and `U` differ in size.

### Method
`gather`

### Signature
`inline batch<T, A> gather(U const *src, batch<V, A> const &index) noexcept`

### Parameters
- **src** (U const*) - Pointer to the source memory.
- **index** (batch<V, A> const&) - Batch of offsets used to gather elements.

### Return Value
A new batch containing the gathered elements.
```

--------------------------------

### Define a generator struct Rot for make_batch_constant

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch_constant.html

Defines a generator type with a static constexpr get method that returns (i + n - 1) % n, producing a batch of (n-1, 0, 1, ... n-2). This generator is used with make_batch_constant to build a batch_constant.

```cpp
struct Rot
{
static constexpr unsigned get(unsigned i, unsigned n)
    {
return (i + n - 1) % n;
    }
};
```

--------------------------------

### load(U const *mem, aligned_mode) noexcept

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch_complex.html

Equivalent to batch::load_aligned().

```APIDOC
## load(U const *mem, aligned_mode) noexcept

### Description
Equivalent to batch::load_aligned().

### Signature
```cpp
inline batch<T, A> load(U const *mem, aligned_mode) noexcept;
```

### Parameters
- **mem** (U const *) - Pointer to aligned memory to load from.

### Returns
A batch loaded from the given memory.
```

--------------------------------

### load()

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Loads values from memory into a batch, optionally masked.

```APIDOC
## load()

### Description
Loads values from memory into a batch, optionally masked.

### Signature
`batch<From, A> load(const From* mem, aligned_mode)`

### Parameters
- `mem` (const From*) - Pointer to the memory to load from.
- `mode` (aligned_mode) - Alignment mode (aligned or unaligned).

### Returns
A batch containing the loaded values.
```

--------------------------------

### xsimd::make_batch_constant()

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch_constant.html

Builds a batch_constant out of a generator function. The generator type G must have a static member get that is used to generate the batch constant. The resulting batch_constant has value {G::get(0, batch_size), ... , G::get(batch_size - 1, batch_size)}.

```APIDOC
## xsimd::make_batch_constant()

### Description
Builds a `batch_constant` out of a generator function. The generator type `G` must have a static member `get` that is used to generate the batch constant. The resulting `batch_constant` has value `{G::get(0, batch_size), ... , G::get(batch_size - 1, batch_size)}`.

### Signature
```cpp
template<typename T, class G, class A = default_arch>
inline constexpr decltype(detail::make_batch_constant<T, G, A>(std::make_index_sequence<batch<T, A>::size>())) xsimd::make_batch_constant() noexcept;
```

### Template Parameters
- **T** - Type of the (non-constant) batch to build.
- **G** - Type used to generate that batch. Must have a static member `get` that is used to generate the batch constant.
- **A** - Architecture type, defaults to `default_arch`.

### Example
```cpp
struct Rot
{
    static constexpr unsigned get(unsigned i, unsigned n)
    {
        return (i + n - 1) % n;
    }
};
```
This generator produces a batch of `(n - 1, 0, 1, ... n-2)`.
```

--------------------------------

### batch_bool()

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch_bool.html

Default constructor that creates a batch initialized with undefined values.

```APIDOC
## batch_bool()

### Description
Default constructor that creates a batch initialized with undefined values.

### Method
Constructor

### Signature
`inline batch_bool() = default`

### Parameters
None

### Returns
None

```

--------------------------------

### insert

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Creates a new batch equivalent to x but with element val set at position pos.

```APIDOC
## insert

### Description
Creates a new batch equivalent to `x` but with element `val` set at position `pos`.

### Method
Function template

### Signature
```cpp
template<class T, class A, size_t I>
inline batch<T, A> insert(batch<T, A> const &x, T val, index<I> pos) noexcept;
```

### Parameters
- **x** (batch<T, A>) - Batch.
- **val** (T) - Value to set.
- **pos** (index<I>) - Index of the updated slot.

### Returns
Copy of `x` with position `pos` set to `val`.
```

--------------------------------

### C++17 if constexpr example for AVX2 sign_i8

Source: https://xsimd.readthedocs.io/en/latest/vectorized_code.html

Use this snippet to add architecture-specific SIMD code within xsimd's batch abstraction. It uses C++17 if constexpr to dispatch to the AVX2 intrinsic _mm256_sign_epi8, with automatic conversion between xsimd::batch and native types. The general xsimd implementation is provided as a fallback for other architectures.

```cpp
template<typename Arch>
auto sign_i8(
    xsimd::batch<int8_t, Arch> const& x,
    xsimd::batch<int8_t, Arch> const& y
) -> xsimd::batch<uint8_t, Arch> {
     // Dedicated instruction dispatch at compile time
     if constexpr (std::is_same_v<Arch, xsimd::avx2>){
         // Automatic conversion back and forth between xsimd::batch and native types
         return _mm256_sign_epi8(x, y);
         // When compiler complains we can be more explicit
         return xsimd::batch<int8_t, Arch>(_mm256_sign_epi8(x.to_native(), y.to_native()));
     }

     // General xsimd implementation
     auto const zero = xsimd::batch<uint8_t, Arch>(0);
     auto const c = xsimd::select(b < 0, -a, a);
     return xsimd::select(b == zero, zero, c);
}
```

--------------------------------

### load (masked, unaligned)

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Creates a batch from a memory buffer using a runtime selection mask. Elements corresponding to false in the mask are not accessed and are zero-initialized.

```APIDOC
## load (masked, unaligned)

### Description
Creates a batch from the buffer `ptr` using a mask. Elements corresponding to `false` in the mask are not accessed in memory and are zero-initialized in the resulting batch.

### Method
Function template

### Signature
```cpp
template<class T, class A = default_arch, bool... Values, class From>
inline batch<T, A> load(From const *ptr, batch_bool_constant<T, A, Values...> const &mask, unaligned_mode) noexcept
```

### Parameters
- **ptr** (const From*) - Required - The memory buffer to read. The buffer does not need to be aligned.
- **mask** (batch_bool_constant<T, A, Values...>) - Required - Runtime selection mask for the elements to load.

### Returns
A new batch instance.
```

--------------------------------

### Usage of xsimd::dispatch() with arch_list

Source: https://xsimd.readthedocs.io/en/latest/api/dispatching.html

Creates a dispatching function targeting avx2 and sse2 architectures, then calls it with data and a size. No architecture-specific compiler flags are required for this code.

```cpp
#include "sum.hpp"

// Create the dispatching function, specifying the architecture we want to
// target.
auto dispatched = xsimd::dispatch<xsimd::arch_list<xsimd::avx2, xsimd::sse2>>(sum{});

// Call the appropriate implementation based on runtime information.
float res = dispatched(data, 17);
```

--------------------------------

### store

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Copies the content of a batch to a memory buffer. The memory does not need to be aligned.

```APIDOC
## store

### Description
Copies the content of batch `val` to the buffer `mem`. The memory does not need to be aligned.

### Template Parameters
- **A** - Architecture.
- **T** - Type of the batch elements.

### Parameters
- **mem** (T*) - The memory buffer to write to.
- **val** (batch<T, A>) - The batch to copy.
- **aligned_mode** (default {}) - Alignment mode indicator.
```

--------------------------------

### load_aligned

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Creates a batch from a memory buffer that must be aligned.

```APIDOC
## load_aligned

### Description
Creates a batch from the buffer `ptr`. The memory needs to be aligned.

### Method
Function template

### Signature
```cpp
template<class A = default_arch, class From>
inline batch<From, A> load_aligned(From const *ptr) noexcept
```

### Parameters
- **ptr** (const From*) - Required - The memory buffer to read.

### Returns
A new batch instance.
```

--------------------------------

### store(T* mem, batch_bool<T,A> mask, Mode = {})

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch.html

Runtime-mask store; see xsimd::store(T*, batch const&, batch_bool<T,A>, Mode).

```APIDOC
## store(T* mem, batch_bool<T,A> mask, Mode = {})

### Description
Runtime-mask store; see xsimd::store(T*, batch const&, batch_bool<T,A>, Mode).

### Method
`store`

### Signature
`template<class Mode = aligned_mode> inline void store(T* mem, batch_bool<T,A> mask, Mode = {}) const noexcept`

### Parameters
- `mem` (T*) - Pointer to the destination buffer.
- `mask` (batch_bool<T,A>) - Mask indicating which elements to store.
- `Mode` (Mode) - Optional mode tag (defaults to aligned_mode).

```

--------------------------------

### store_as()

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Stores batch values, forcing a type conversion.

```APIDOC
## store_as()

### Description
Stores batch values, forcing a type conversion.

### Signature
`void store_as(To* mem, const batch<From, A>& self, aligned_mode)`

### Parameters
- `mem` (To*) - Pointer to the destination memory.
- `self` (const batch<From, A>&) - The batch to store.
- `mode` (aligned_mode) - Alignment mode.

### Returns
Nothing.
```

--------------------------------

### store(U* mem, unaligned_mode)

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch.html

Equivalent to batch::store_unaligned().

```APIDOC
## store(U* mem, unaligned_mode)

### Description
Equivalent to batch::store_unaligned().

### Method
`store`

### Signature
`template<class U> inline void store(U* mem, unaligned_mode) const noexcept`

### Parameters
- `mem` (U*) - Pointer to the destination buffer. Does not need to be aligned.
- `unaligned_mode` - Mode tag indicating unaligned store.

```

--------------------------------

### xsimd::common::supported

Source: https://xsimd.readthedocs.io/en/latest/api/arch.html

Static function to check if the architecture is supported at compile-time.

```APIDOC
## [STATIC] xsimd::common::supported()

### Description
Whether this architecture is supported at compile-time.

### Method
static inline constexpr bool supported() noexcept

### Parameters
None

### Returns
- **bool** - True if the architecture is supported at compile-time.

```

--------------------------------

### expand

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Loads contiguous elements from a batch and places them in slots selected by a mask, zeroing the other slots.

```APIDOC
## expand

### Description
Load contiguous elements from `x` and place them in slots selected by `mask`, zeroing the other slots.

### Function Signature
```cpp
template<class T, class A>
inline batch<T, A> expand(batch<T, A> const &x, batch_bool<T, A> const &mask) noexcept
```

### Parameters
- **x** (batch<T, A>) - Required - The input batch.
- **mask** (batch_bool<T, A>) - Required - The mask indicating which slots to fill.

### Returns
A new batch with the selected slots filled and the rest zeroed.
```

--------------------------------

### batch(T val)

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch.html

Constructor that creates a batch with all elements initialized to the given scalar value.

```APIDOC
## batch(T val)

### Description
Create a batch with all element initialized to `val`.

### Method
Constructor

### Signature
```cpp
inline batch(T val) noexcept
```

### Parameters
- **val** (T) - Required - The value to initialize all elements of the batch.

### Returns
A batch object with all elements set to `val`.
```

--------------------------------

### load_as (unaligned)

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Creates a batch from the buffer ptr and the specified batch value type To. The memory does not need to be aligned.

```APIDOC
## load_as (unaligned)

### Description
Creates a batch from the buffer `ptr` and the specified batch value type `To`. The memory does not need to be aligned.

### Method
Function template

### Signature
```cpp
template<class To, class A = default_arch, class From>
inline simd_return_type<From, To, A> load_as(From const *ptr, unaligned_mode) noexcept;
```

### Parameters
- **ptr** (From const*) - The memory buffer to read.

### Returns
A new batch instance.
```

--------------------------------

### operator+

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch_complex.html

Shorthand for xsimd::add(). Adds two batches element-wise.

```APIDOC
## operator+

### Description
Shorthand for `xsimd::add()`. Adds two batches element-wise.

### Method
`operator+`

### Signature
`inline friend batch operator+(batch const &self, batch const &other) noexcept`

### Parameters
- **self** (batch const&) - The first batch.
- **other** (batch const&) - The second batch.

### Return Value
The element-wise sum of the two batches.
```

--------------------------------

### compress()

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Packs elements according to a mask.

```APIDOC
## compress()

### Description
Packs elements according to a mask.

### Signature
`batch<T, A> compress(const batch<T, A>& self, const batch_bool<T, A>& mask)`

### Parameters
- `self` (const batch<T, A>&) - The input batch.
- `mask` (const batch_bool<T, A>&) - Mask indicating which elements to pack.

### Returns
A batch with packed elements.
```

--------------------------------

### store_as (unaligned)

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Copies the content of a batch to a memory buffer. The memory does not need to be aligned.

```APIDOC
## store_as (unaligned)

### Description
Copies the content of batch `src` to the buffer `dst`. The memory does not need to be aligned.

### Template Parameters
- **To** - Type of the destination buffer.
- **A** (default_arch) - Architecture.
- **From** - Type of the source batch.

### Parameters
- **dst** (To*) - The memory buffer to write to.
- **src** (batch<From, A>) - The batch to copy.
- **unaligned_mode** - Alignment mode indicator.
```

--------------------------------

### load(U const *mem, unaligned_mode) noexcept

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch_complex.html

Equivalent to batch::load_unaligned().

```APIDOC
## load(U const *mem, unaligned_mode) noexcept

### Description
Equivalent to batch::load_unaligned().

### Signature
```cpp
inline batch<T, A> load(U const *mem, unaligned_mode) noexcept;
```

### Parameters
- **mem** (U const *) - Pointer to unaligned memory to load from.

### Returns
A batch loaded from the given memory.
```

--------------------------------

### swizzle()

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Rearranges slots within the batch according to a compile-time pattern.

```APIDOC
## swizzle()

### Description
Rearranges slots within the batch according to a compile-time pattern.

### Signature
`enable_if_t<is_arithmetic_v<T>, batch<T, A>> swizzle(const batch<T, A>& self, batch_constant<Vt, A, Values...> mask)`

### Parameters
- `self` (const batch<T, A>&) - The input batch.
- `mask` (batch_constant<Vt, A, Values...>) - Compile-time pattern for rearrangement.

### Returns
A batch with rearranged slots.
```

--------------------------------

### slide_right()

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Bitwise shifts the whole batch to the right.

```APIDOC
## slide_right()

### Description
Bitwise shifts the whole batch to the right.

### Signature
`batch<T, A> slide_right(const batch<T, A>& self)`

### Parameters
- `self` (const batch<T, A>&) - The input batch.

### Returns
A batch shifted right.
```

--------------------------------

### store (aligned, runtime mask)

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Copies selected elements of a batch to a memory buffer using a runtime mask. Elements corresponding to false in the mask are not written and leave the contents of mem untouched.

```APIDOC
## store (aligned, runtime mask)

### Description
Copies selected elements of a batch `val` to the buffer `mem` using a runtime mask. Elements corresponding to `false` in the mask are not written and leave the contents of `mem` untouched. No type conversion is performed: `mem` must point to `T`. Prefer the `batch_bool_constant` overload whenever the mask is known at compile time.

### Method
store

### Signature
```cpp
template<class T, class A = default_arch>
inline void store(T* mem, batch<T, A> const& val, batch_bool<T, A> mask, aligned_mode = {}) noexcept
```

### Parameters
- **mem** (T*) - The memory buffer to write to.
- **val** (batch<T, A> const&) - The batch to copy from.
- **mask** (batch_bool<T, A>) - Runtime selection mask for the elements to store.

```

--------------------------------

### operator&&

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch.html

Performs logical AND on two batches. Shorthand for xsimd::logical_and().

```APIDOC
## operator&&

### Description
Performs logical AND on two batches. Shorthand for xsimd::logical_and().

### Signature
```cpp
inline friend batch operator&&(batch const &self, batch const &other) noexcept;
```

### Parameters
- **self** (batch const &) - The left-hand operand.
- **other** (batch const &) - The right-hand operand.

### Returns
- **batch** - The result of the logical AND.
```

--------------------------------

### make_sized_batch

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch.html

Type utility to select a batch of given type and size.

```APIDOC
## make_sized_batch

### Description
Type utility to select a batch of given type and size.

### Signature
```cpp
template<typename T, std::size_t N>
struct make_sized_batch;
```

### Template Parameters
- **T** (typename) - The element type.
- **N** (std::size_t) - The number of elements.

### Remarks
This is a type utility, not a function.
```

--------------------------------

### operator/

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch.html

Divides two batches element-wise. Shorthand for xsimd::div().

```APIDOC
## operator/

### Description
Divides two batches element-wise. Shorthand for xsimd::div().

### Signature
```cpp
inline friend batch operator/(batch const &self, batch const &other) noexcept;
```

### Parameters
- **self** (batch const &) - The left-hand operand.
- **other** (batch const &) - The right-hand operand.

### Returns
- **batch** - The result of the division.
```

--------------------------------

### construct

Source: https://xsimd.readthedocs.io/en/latest/api/aligned_allocator.html

Constructs an object of type T in allocated uninitialized memory pointed to by p, using placement-new.

```APIDOC
## construct

### Description
Constructs an object of type `T` in allocated uninitialized memory pointed to by `p`, using placement-new.

### Parameters
- **p** – pointer to allocated uninitialized memory.
- **args** – the constructor arguments to use.

```

--------------------------------

### store()

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Stores batch values to memory, optionally masked.

```APIDOC
## store()

### Description
Stores batch values to memory, optionally masked.

### Signature
`void store(T* mem, const batch<T, A>& self, aligned_mode)`

### Parameters
- `mem` (T*) - Pointer to the destination memory.
- `self` (const batch<T, A>&) - The batch to store.
- `mode` (aligned_mode) - Alignment mode.

### Returns
Nothing.
```

--------------------------------

### broadcast_as

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Creates a batch from a single value with a specified batch value type.

```APIDOC
## broadcast_as

### Description
Creates a batch from the single value `v` and the specified batch value type `To`.

### Function Signature
```cpp
template<class To, class A = default_arch, class From>
inline simd_return_type<From, To, A> broadcast_as(From v) noexcept
```

### Parameters
- **v** (From) - Required - The value used to initialize the batch.

### Returns
A new batch instance.
```

--------------------------------

### batch::broadcast(U val)

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch.html

Creates a batch with all elements set to the given value. Equivalent to constructing a batch with a single scalar value.

```APIDOC
## batch::broadcast(U val)

### Description
Creates a batch where all elements are set to the provided scalar value. Equivalent to `batch::batch(T val)`.

### Method
broadcast

### Signature
`template<class U> static batch<T, A> broadcast(U val) noexcept`

### Parameters
- **val** (U) - The scalar value to broadcast to all elements.

### Return Value
- **batch<T, A>** - A batch with all elements equal to `val`.

```

--------------------------------

### Basic Functions

Source: https://xsimd.readthedocs.io/en/latest/api/math_index.html

Basic mathematical functions that operate on batches: absolute value, remainder, min/max, clipping, etc.

```APIDOC
## abs(batch)

### Description
Computes the absolute value of each element in the batch.

### Function Signature
`batch<T, A> abs(const batch<T, A>& self)`

### Parameters
- **self** (batch<T, A>) - Input batch.

### Returns
- **batch<T, A>** - Batch containing the absolute values.

## fabs(batch)

### Description
Computes the absolute value of floating-point elements in the batch.

### Function Signature
`batch<T, A> fabs(const batch<T, A>& self)`

### Parameters
- **self** (batch<T, A>) - Input batch.

### Returns
- **batch<T, A>** - Batch containing the absolute values.

## fmod(batch, batch)

### Description
Computes the remainder of the floating-point division operation.

### Function Signature
`batch<T, A> fmod(const batch<T, A>& x, const batch<T, A>& y)`

### Parameters
- **x** (batch<T, A>) - Dividend batch.
- **y** (batch<T, A>) - Divisor batch.

### Returns
- **batch<T, A>** - Batch containing the remainders.

## remainder(batch, batch)

### Description
Computes the signed remainder of the division operation.

### Function Signature
`batch<T, A> remainder(const batch<T, A>& x, const batch<T, A>& y)`

### Parameters
- **x** (batch<T, A>) - Dividend batch.
- **y** (batch<T, A>) - Divisor batch.

### Returns
- **batch<T, A>** - Batch containing the signed remainders.

## min(batch, batch)

### Description
Returns the smaller of two batches element-wise.

### Function Signature
`batch<T, A> min(const batch<T, A>& x, const batch<T, A>& y)`

### Parameters
- **x** (batch<T, A>) - First batch.
- **y** (batch<T, A>) - Second batch.

### Returns
- **batch<T, A>** - Batch containing the element-wise minimum.

## max(batch, batch)

### Description
Returns the larger of two batches element-wise.

### Function Signature
`batch<T, A> max(const batch<T, A>& x, const batch<T, A>& y)`

### Parameters
- **x** (batch<T, A>) - First batch.
- **y** (batch<T, A>) - Second batch.

### Returns
- **batch<T, A>** - Batch containing the element-wise maximum.

## fmin(batch, batch)

### Description
Returns the smaller of two batches of floating-point values element-wise.

### Function Signature
`batch<T, A> fmin(const batch<T, A>& x, const batch<T, A>& y)`

### Parameters
- **x** (batch<T, A>) - First batch.
- **y** (batch<T, A>) - Second batch.

### Returns
- **batch<T, A>** - Batch containing the element-wise minimum.

## fmax(batch, batch)

### Description
Returns the larger of two batches of floating-point values element-wise.

### Function Signature
`batch<T, A> fmax(const batch<T, A>& x, const batch<T, A>& y)`

### Parameters
- **x** (batch<T, A>) - First batch.
- **y** (batch<T, A>) - Second batch.

### Returns
- **batch<T, A>** - Batch containing the element-wise maximum.

## fdim(batch, batch)

### Description
Computes the positive difference between two batches element-wise.

### Function Signature
`batch<T, A> fdim(const batch<T, A>& x, const batch<T, A>& y)`

### Parameters
- **x** (batch<T, A>) - First batch.
- **y** (batch<T, A>) - Second batch.

### Returns
- **batch<T, A>** - Batch containing the positive differences.

## clip(batch, batch, batch)

### Description
Performs a clipping operation on the batch.

### Function Signature
`batch<T, A> clip(const batch<T, A>& x, const batch<T, A>& lo, const batch<T, A>& hi)`

### Parameters
- **x** (batch<T, A>) - Input batch.
- **lo** (batch<T, A>) - Lower bound batch.
- **hi** (batch<T, A>) - Upper bound batch.

### Returns
- **batch<T, A>** - Batch with values clipped to [lo, hi].
```

--------------------------------

### asin(batch<T, A> const &x)

Source: https://xsimd.readthedocs.io/en/latest/api/math_index.html

Computes the arc sine of the batch x. Returns the arc sine of x.

```APIDOC
## asin(batch<T, A> const &x)

### Description
Computes the arc sine of the batch `x`.

### Signature
```cpp
template<class T, class A>
inline batch<T, A> asin(batch<T, A> const &x) noexcept
```

### Parameters
- **x** (batch<T, A>) - Required - batch of floating point values.

### Returns
- **batch<T, A>** - the arc sine of `x`.
```

--------------------------------

### load_aligned()

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Loads values from aligned memory into a batch.

```APIDOC
## load_aligned()

### Description
Loads values from aligned memory into a batch.

### Signature
`batch<From, A> load_aligned(const From* mem)`

### Parameters
- `mem` (const From*) - Pointer to aligned memory.

### Returns
A batch containing the loaded values.
```

--------------------------------

### load_aligned(U const *mem) noexcept

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch_complex.html

Loads a batch from aligned memory. May involve a conversion if U is different from T.

```APIDOC
## load_aligned(U const *mem) noexcept

### Description
Loads a batch from aligned memory. May involve a conversion if `U` is different from `T`.

### Signature
```cpp
inline batch<T, A> load_aligned(U const *mem) noexcept;
```

### Parameters
- **mem** (U const *) - Pointer to aligned memory to load from.

### Returns
A batch loaded from the given memory.
```

--------------------------------

### store_aligned

Source: https://xsimd.readthedocs.io/en/latest/api/data_transfer.html

Copies the content of a batch to a memory buffer. The memory must be aligned.

```APIDOC
## store_aligned

### Description
Copies content of batch `val` to the buffer `mem`. The memory needs to be aligned.

### Signature
```cpp
template<class A, class T>
inline void store_aligned(T* mem, batch<T, A> const& val) noexcept
```

### Parameters
- **mem** (T*) - The memory buffer to write to.
- **val** (batch<T, A> const&) - The batch to copy from.
```

--------------------------------

### batch::load(U const *mem, aligned_mode)

Source: https://xsimd.readthedocs.io/en/latest/api/xsimd_batch.html

Loads a batch from aligned memory. Equivalent to batch::load_aligned().

```APIDOC
## batch::load(U const *mem, aligned_mode)

### Description
Loads a batch from aligned memory. Equivalent to `batch::load_aligned()`.

### Method
load

### Signature
`template<class U> static batch<T, A> load(U const *mem, aligned_mode) noexcept`

### Parameters
- **mem** (U const *) - Pointer to aligned memory from which to load.
- **aligned_mode** - Tag indicating aligned memory access.

### Return Value
- **batch<T, A>** - A batch loaded from the given memory.

```
Tokens:
Raw