vec.H

// ===========================================================================
//
// generic template for Vec
//
// This source code file is part of the following software:
//
//    - the low-level C++ template SIMD library
//    - the SIMD implementation of the MinWarping and the 2D-Warping methods
//      for local visual homing.
//
// The software is provided based on the accompanying license agreement in the
// file LICENSE.md.
// The software is provided "as is" without any warranty by the licensor and
// without any liability of the licensor, and the software may not be
// distributed by the licensee; see the license agreement for details.
//
// (C) Ralf Möller
//     Computer Engineering
//     Faculty of Technology
//     Bielefeld University
//     www.ti.uni-bielefeld.de
//
// ===========================================================================
 
// 13. Feb 23 (Jonas Keller): removed "SIMD"-prefix from most types
// (versions with "SIMD"-prefix are still available for backward
// compatibility in SIMDBackwardCompat.H)
 
// 09. Mar 23 (Jonas Keller): added doxygen documentation
 
#pragma once
#ifndef SIMD_VEC_H_
#define SIMD_VEC_H_
 
#include "defs.H"
#include "types.H"
 
#include <algorithm>
#include <cstddef>
#include <type_traits>
 
namespace simd {
 
// TODO: - absdiff also for unsigned types -> SSE lecture vecintrin66
// TODO: - bitwise shift: what about float?
// TODO: - loadr / storer
// TODO: - element-wise rotation in a vector using alignre
// TODO: - functions for rsqrt, rcp Newton *steps*?
// TODO: - add to names rcp, rsqrt something with "estimate"?
// TODO: - NEON has a "set1" with immediate arguments (vmovq_n), so it would
// TODO:   be nice to have a set1const function with template argument, but
// TODO:   this only works for integers since float template parameter are not
// TODO:   allowed by the standard
 
// ===========================================================================
// generic template for Vec and Mask
// ===========================================================================
 
// 30. Sep 19 (rm): Mask support contributed by Markus Vieth
 
// specialized for type of elements and number of bytes in the SIMD vector
template <typename T, size_t SIMD_WIDTH_DEFAULT_NATIVE>
class Vec
#ifdef DOXYGEN
{
public:
  static constexpr size_t elements = SIMD_WIDTH / sizeof(T);
 
  static constexpr size_t elems = elements;
 
  static constexpr size_t bytes = SIMD_WIDTH;
 
  // 05. Sep 23 (Jonas Keller): added allocator
  using allocator = aligned_allocator<Vec<T, SIMD_WIDTH>, SIMD_WIDTH>;
}
#endif
;
 
template <typename T, size_t SIMD_WIDTH_DEFAULT_NATIVE>
class Mask
#ifdef DOXYGEN
{
public:
  explicit SIMD_INLINE Mask<T, SIMD_WIDTH>(const Vec<T, SIMD_WIDTH> &x);
 
  explicit SIMD_INLINE Mask<T, SIMD_WIDTH>(const uint64_t x);
 
  explicit SIMD_INLINE operator Vec<T, SIMD_WIDTH>() const { return mask; };
 
  explicit SIMD_INLINE operator uint64_t() const;
 
  SIMD_INLINE bool operator[](const size_t i) const;
 
  SIMD_INLINE bool operator==(const Mask<T, SIMD_WIDTH> &other) const;
}
#endif
;
 
// ===========================================================================
// helper functions for templates converting from Tin to Tout
// ===========================================================================
 
// numInVecs() and numOutVecs() assume that either
// - a single vector is extended into multiple vectors or
// - multiple vectors are packed into a single vector
//
// numSIMDVecsElements encodes the number of elements in *all* input / all
// output vectors
//
// removed: numSIMDVecElements encodes the number of elements in each vector
// (or use Vec::elements instead)
//
// removed: numInputSIMDVecElements/numOutputSIMDVecElements encode
// the number of elements in *each* input / output vector
 
template <typename Tout, typename Tin>
static constexpr SIMD_INLINE size_t numInVecs()
{
  return (sizeof(Tout) < sizeof(Tin)) ? (sizeof(Tin) / sizeof(Tout)) : 1;
}
 
template <typename Tout, typename Tin>
static constexpr SIMD_INLINE size_t numOutVecs()
{
  return (sizeof(Tout) > sizeof(Tin)) ? (sizeof(Tout) / sizeof(Tin)) : 1;
}
 
template <typename Tout, typename Tin, size_t SIMD_WIDTH>
static constexpr SIMD_INLINE size_t numSIMDVecsElements()
{
  return (sizeof(Tout) > sizeof(Tin)) ? Vec<Tin, SIMD_WIDTH>::elems :
                                        Vec<Tout, SIMD_WIDTH>::elems;
}
 
// 13. May 23 (Jonas Keller): added BigEnoughFloat
 
namespace internal {
namespace vec {
// std::max and std::min are not constexpr in C++11, so we need to provide our
// own, since we need them in a constexpr context
template <typename T>
constexpr const T &max(const T &a, const T &b)
{
  return (a < b) ? b : a;
}
 
template <typename T>
constexpr const T &min(const T &a, const T &b)
{
  return (a < b) ? a : b;
}
} // namespace vec
} // namespace internal
 
template <typename Tout, typename Tin>
using BigEnoughFloat =
#ifdef SIMD_64BIT_TYPES
  typename std::conditional<internal::vec::max(sizeof(Tout), sizeof(Tin)) <=
                              sizeof(Float),
                            Float, Double>::type;
#else
  Float;
#endif
 
// 22. Jan 23 (Jonas Keller): removed primary template functions, as they are
// not needed anymore due to a wrapper layer
 
} // namespace simd
 
#endif