#include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <functional>
#include <istream>
#include <ostream>
#include <type_traits>
#include <utility>
#include <dune/common/classname.hh>
#include <dune/common/indices.hh>
#include <dune/common/simd/base.hh>
#include <dune/common/simd/defaults.hh>
#include <dune/common/typetraits.hh>

Classes
class	Dune::AlignedBase< align, Impl >
	CRTP base mixin class to check alignment. More...

struct	Dune::IsNumber< AlignedNumberImpl::AlignedNumber< T, align > >

class	Dune::AlignedNumberImpl::AlignedNumber< T, align >
	aligned wrappers for arithmetic types More...

struct	Dune::Simd::Overloads::ScalarType< AlignedNumber< T, align > >

struct	Dune::Simd::Overloads::RebindType< U, AlignedNumber< T, align > >

struct	Dune::Simd::Overloads::LaneCount< AlignedNumber< T, align > >

Namespaces
namespace	Dune
	Dune namespace.

namespace	Dune::AlignedNumberImpl

namespace	Dune::Simd
	Namespace for vectorization interface functions used by library developers.

namespace	Dune::Simd::Overloads
	Namespace for the overloads and specializations that make up a SIMD implementation.

Macros
#define	DUNE_ASSIGN_OP(OP)

#define	DUNE_BINARY_OP(OP)

#define	DUNE_UNARY_FUNC(name)

Typedefs
using	Dune::ViolatedAlignmentHandler = std::function< void(const char , std::size_t, const void )>
	type of the handler called by `violatedAlignment()`

Functions
ViolatedAlignmentHandler &	Dune::violatedAlignmentHandler ()
	access the handler called by `violatedAlignment()`

void	Dune::violatedAlignment (const char className, std::size_t expectedAlignment, const void address)
	called when an alignment violation is detected

bool	Dune::isAligned (const void *p, std::size_t align)
	check whether an address conforms to the given alignment

template<std::size_t align = debugAlignment, class T >
AlignedNumber< T, align >	Dune::aligned (T value)
	align a value to a certain alignment

	Dune::AlignedNumberImpl::DUNE_BINARY_OP (+)

	Dune::AlignedNumberImpl::DUNE_BINARY_OP (-)

DUNE_BINARY_OP *	Dune::AlignedNumberImpl::DUNE_BINARY_OP (/);DUNE_BINARY_OP(%

DUNE_BINARY_OP^	Dune::AlignedNumberImpl::DUNE_BINARY_OP (&);DUNE_BINARY_OP(\|

	Dune::AlignedNumberImpl::DUNE_BINARY_OP (<<)

	Dune::AlignedNumberImpl::DUNE_BINARY_OP (> >)

	Dune::AlignedNumberImpl::DUNE_BINARY_OP (==)

	Dune::AlignedNumberImpl::DUNE_BINARY_OP (!=)

	Dune::AlignedNumberImpl::DUNE_BINARY_OP (<=)

	Dune::AlignedNumberImpl::DUNE_BINARY_OP (>=)

DUNE_BINARY_OP &&	Dune::AlignedNumberImpl::DUNE_BINARY_OP (\|\|);#define DUNE_UNARY_FUNC(name) DUNE_UNARY_FUNC(abs

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (acos)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (acosh)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (asin)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (asinh)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (atan)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (atanh)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (cbrt)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (ceil)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (cos)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (cosh)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (erf)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (erfc)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (exp)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (exp2)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (expm1)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (fabs)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (floor)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (ilogb)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (lgamma)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (llrint)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (llround)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (log)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (log10)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (log1p)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (log2)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (logb)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (lrint)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (lround)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (nearbyint)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (rint)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (round)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (sin)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (sinh)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (sqrt)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (tan)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (tanh)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (tgamma)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (trunc)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (isfinite)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (isinf)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (isnan)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (isnormal)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (signbit)

	Dune::AlignedNumberImpl::DUNE_UNARY_FUNC (real)

template<class T , std::size_t align>
auto	Dune::AlignedNumberImpl::max (const AlignedNumber< T, align > &a, const AlignedNumber< T, align > &b)

template<class T , std::size_t align>
auto	Dune::AlignedNumberImpl::max (const T &a, const AlignedNumber< T, align > &b)

template<class T , std::size_t align>
auto	Dune::AlignedNumberImpl::max (const AlignedNumber< T, align > &a, const T &b)

template<class T , std::size_t align>
auto	Dune::AlignedNumberImpl::min (const AlignedNumber< T, align > &a, const AlignedNumber< T, align > &b)

template<class T , std::size_t align>
auto	Dune::AlignedNumberImpl::min (const T &a, const AlignedNumber< T, align > &b)

template<class T , std::size_t align>
auto	Dune::AlignedNumberImpl::min (const AlignedNumber< T, align > &a, const T &b)

template<class T , std::size_t align>
AlignedNumber< T, align >	Dune::cond (const AlignedNumber< bool, align > &b, const AlignedNumber< T, align > &v1, const AlignedNumber< T, align > &v2)

template<class T , std::size_t align>
T	Dune::max_value (const AlignedNumber< T, align > &val)

template<class T , std::size_t align>
T	Dune::min_value (const AlignedNumber< T, align > &val)

template<std::size_t align>
bool	Dune::any_true (const AlignedNumber< bool, align > &val)

template<std::size_t align>
bool	Dune::all_true (const AlignedNumber< bool, align > &val)

template<class T , std::size_t align>
T &	Dune::Simd::Overloads::lane (ADLTag< 5 >, std::size_t l, AlignedNumber< T, align > &v)

template<class T , std::size_t align>
T	Dune::Simd::Overloads::lane (ADLTag< 5 >, std::size_t l, const AlignedNumber< T, align > &v)

template<class T , std::size_t align>
const AlignedNumber< T, align > &	Dune::Simd::Overloads::cond (ADLTag< 5 >, AlignedNumber< bool, align > mask, const AlignedNumber< T, align > &ifTrue, const AlignedNumber< T, align > &ifFalse)

template<std::size_t align>
bool	Dune::Simd::Overloads::anyTrue (ADLTag< 5 >, const AlignedNumber< bool, align > &mask)

Variables
static constexpr auto	Dune::debugAlignment = 2*alignof(std::max_align_t)
	an alignment large enough to trigger alignment errors

Macro Definition Documentation

◆ DUNE_ASSIGN_OP

#define DUNE_ASSIGN_OP ( OP )

Value:

      template<class U, std::size_t uAlign,                             \
               class = std::enable_if_t<                                \
                         ( uAlign <= align &&                           \
                           sizeof(std::declval<T&>() OP std::declval<U>()) ) \
                           > >                                          \
      AlignedNumber &operator OP(const AlignedNumber<U, uAlign> &u)     \
      {                                                                 \
        value_ OP U(u);                                                 \
        return *this;                                                   \
      }                                                                 \
                                                                        \
      template<class U,                                                 \
               class = std::void_t<decltype(std::declval<T&>() OP       \
                                            std::declval<U>())> >       \
      AlignedNumber &operator OP(const U &u)                            \
      {                                                                 \
        value_ OP u;                                                    \
        return *this;                                                   \
      }                                                                 \
                                                                        \
      static_assert(true, "Require semicolon to unconfuse editors")

◆ DUNE_BINARY_OP

#define DUNE_BINARY_OP ( OP )

Value:

    template<class T, std::size_t tAlign, class U, std::size_t uAlign,  \
             class = std::void_t<decltype(std::declval<T>()             \
                                     OP std::declval<U>())> >           \
    decltype(auto)                                                      \
      operator OP(const AlignedNumber<T, tAlign> &t,                    \
                  const AlignedNumber<U, uAlign> &u)                    \
    {                                                                   \
      /* can't use std::max(); not constexpr */                         \
      return aligned<(tAlign > uAlign ? tAlign : uAlign)>(T(t) OP U(u)); \
    }                                                                   \
                                                                        \
    template<class T, class U, std::size_t uAlign,                      \
             class = std::void_t<decltype(std::declval<T>()             \
                                     OP std::declval<U>())> >           \
    decltype(auto)                                                      \
      operator OP(const T &t, const AlignedNumber<U, uAlign> &u)        \
    {                                                                   \
      return aligned<uAlign>(t OP U(u));                                \
    }                                                                   \
                                                                        \
    template<class T, std::size_t tAlign, class U,                      \
             class = std::void_t<decltype(std::declval<T>()             \
                                     OP std::declval<U>())> >           \
    decltype(auto)                                                      \
      operator OP(const AlignedNumber<T, tAlign> &t, const U &u)        \
    {                                                                   \
      return aligned<tAlign>(T(t) OP u);                                \
    }                                                                   \
                                                                        \
    static_assert(true, "Require semicolon to unconfuse editors")

◆ DUNE_UNARY_FUNC

#define DUNE_UNARY_FUNC ( name )

Value:

    template<class T, std::size_t align>                            \
    decltype(auto) name(const AlignedNumber<T, align> &u)           \
    {                                                               \
      using std::name;                                              \
      return aligned<align>(name(T(u)));                            \
    }                                                               \
    static_assert(true, "Require semicolon to unconfuse editors")

Classes

Namespaces

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ DUNE_ASSIGN_OP

◆ DUNE_BINARY_OP

◆ DUNE_UNARY_FUNC