load

eve::load = functor<load_t>

inlineconstexpr

Header file

#include <eve/module/core.hpp>

Callable Signatures

namespace eve
{
  // Regular overloads
  template<detail::data_source Ptr>
  wide_value_type_t<Ptr> load(Ptr ptr) const noexcept;                                                           // 1
 
  template<detail::data_source Ptr, std::ptrdiff_t N>
  as_wide_t<value_type_t<Ptr>, fixed<N>> load(Ptr ptr, fixed<N>) const noexcept;                                 // 1
 
  template<detail::data_source Ptr, arithmetic_simd_value Wide>
  requires std::same_as<value_type_t<Ptr>, element_type_t<Wide>>
  Wide load(Ptr ptr, as<Wide> tgt) const noexcept;                                                               // 1
 
  template<detail::data_source Ptr, logical_simd_value Wide>
  (sizeof(value_type_t<Ptr>) == sizeof(element_type_t<Wide>))
  Wide load(Ptr ptr, as<Wide> tgt) const noexcept;                                                               // 1
 
  // Conditional overloads
  auto load[relative_conditional_expr c](/* any non-iterator version of the above overloads */) const noexcept;  // 2
 
  // Semantic options
  auto load[unsafe](/* any non-iterator version of the above overloads */) const noexcept;                       // 3
}

Parameters

• ptr: A data source referencing the data to load.
• c: A relative conditional expression that determines which elements to load.

Return value

1. A SIMD value containing the element referenced by the data source or the iterators.
2. Same as 1., but elements whose corresponding condition mask lane evaluates to false are left undefined.
3. Same as 1., but uses as scalar version of the operation if a sanitizer is enabled.

Note

1. and 3. may be sub-optimal for non-contiguous iterators.

Example

#include <eve/eve.hpp>
#include <iostream>
#include <vector>
#include <list>
 
int main()
{
  std::array<double, 16> doubles = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f};
  std::cout << eve::load(doubles.data() + 3) << "\n";
 
  std::vector<float> vec = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f};
  std::cout << eve::load(vec.data(), eve::as<eve::wide<float, eve::fixed<4>>>{}) << "\n";
 
  std::list<float> lst = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f};
  std::cout << eve::load(lst.begin(), eve::lane<8>) << "\n";
 
  int arr[8] = {2, 4, 6, 8, 10, 12, 14, 16};
  std::cout << eve::load[eve::keep_between(2, 5).else_(-99)](arr, eve::lane<8>) << "\n";
}