Classes | Macros | Typedefs | Functions | Variables
PointerVector.hpp File Reference

Defines class PointerVector. More...

#include <cmath>
#include <functional>
#include "ErrorHandling/Assert.hpp"
#include "Utilities/Blaze.hpp"
#include <blaze/math/CustomVector.h>
#include <blaze/system/Version.h>
#include <blaze/util/typetraits/RemoveConst.h>

Go to the source code of this file.

Classes

struct  blaze::StepFunction
 
struct  blaze::DivideScalarByVector< ST >
 
struct  blaze::AddScalar< ST >
 
struct  blaze::SubScalarRhs< ST >
 
struct  blaze::SubScalarLhs< ST >
 
struct  PointerVector< Type, AF, PF, TF, ExprResultType >
 A raw pointer endowed with expression template support via the Blaze library. More...
 

Macros

#define SPECTRE_BLAZE_ALLOCATOR(_TYPE_T, _SIZE_V)   new _TYPE_T[_SIZE_V]
 
#define SPECTRE_BLAZE_DEALLOCATOR   blaze::ArrayDelete()
 
#define MAKE_MATH_ASSIGN_EXPRESSION_POINTERVECTOR(OP, TYPE)
 Generates the OP assignment operator for the type TYPE More...
 

Typedefs

template<typename T >
using BlazePow = blaze::UnaryPow< T >
 
template<bool B>
using blaze_enable_if_t = blaze::EnableIf_t< B >
 
template<typename T >
using blaze_remove_const_t = blaze::RemoveConst_t< T >
 
template<typename T >
using blaze_simd_trait_t = blaze::SIMDTrait_t< T >
 
template<typename T >
using blaze_element_type_t = blaze::ElementType_t< T >
 
template<typename T >
using blaze_result_type_t = blaze::ResultType_t< T >
 
template<typename T1 , typename T2 >
using blaze_mult_trait_t = blaze::MultTrait_t< T1, T2 >
 
template<typename T1 , typename T2 >
using blaze_div_trait_t = blaze::DivTrait_t< T1, T2 >
 
template<typename T1 , typename T2 >
using blaze_cross_trait_t = blaze::CrossTrait_t< T1, T2 >
 
template<typename T >
using blaze_const_iterator_t = blaze::ConstIterator_t< T >
 

Functions

template<typename T >
BLAZE_ALWAYS_INLINE SIMDdouble blaze::step_function (const SIMDf64< T > &v) noexcept
 
BLAZE_ALWAYS_INLINE double blaze::step_function (const double &v) noexcept
 
template<typename VT , bool TF>
decltype(auto) BLAZE_ALWAYS_INLINE step_function (const blaze::DenseVector< VT, TF > &vec) noexcept
 
template<typename VT , bool TF>
decltype(auto) BLAZE_ALWAYS_INLINE StepFunction (const blaze::DenseVector< VT, TF > &vec) noexcept
 
template<typename Scalar , typename VT , bool TF, typename = blaze_enable_if_t<blaze_is_numeric<Scalar>>>
decltype(auto) BLAZE_ALWAYS_INLINE blaze::operator/ (Scalar scalar, const blaze::DenseVector< VT, TF > &vec)
 
template<typename VT , bool TF, typename Scalar , typename = blaze_enable_if_t<blaze_is_numeric<Scalar>>>
decltype(auto) blaze::operator+ (const blaze::DenseVector< VT, TF > &vec, Scalar scalar)
 
template<typename Scalar , typename VT , bool TF, typename = blaze_enable_if_t<blaze_is_numeric<Scalar>>>
decltype(auto) blaze::operator+ (Scalar scalar, const blaze::DenseVector< VT, TF > &vec)
 
template<typename VT , bool TF, typename Scalar , typename = blaze_enable_if_t<blaze_is_numeric<Scalar>>>
VT & blaze::operator+= (blaze::DenseVector< VT, TF > &vec, Scalar scalar)
 
template<typename VT , bool TF, typename Scalar , typename = blaze_enable_if_t<blaze_is_numeric<Scalar>>>
decltype(auto) blaze::operator- (const blaze::DenseVector< VT, TF > &vec, Scalar scalar)
 
template<typename VT , bool TF, typename Scalar , typename = blaze_enable_if_t<blaze_is_numeric<Scalar>>>
decltype(auto) blaze::operator- (Scalar scalar, const blaze::DenseVector< VT, TF > &vec)
 
template<typename VT , bool TF, typename Scalar , typename = blaze_enable_if_t<blaze_is_numeric<Scalar>>>
VT & blaze::operator-= (blaze::DenseVector< VT, TF > &vec, Scalar scalar)
 
template<typename Type , bool AF, bool PF, bool TF, typename ExprResultType , typename T , typename = std::enable_if_t<std::is_fundamental<std::decay_t<T>>::value>>
decltype(auto) pow (const PointerVector< Type, AF, PF, TF, ExprResultType > &t, T &&exponent) noexcept
 

Variables

const bool blaze_unaligned = blaze::unaligned != 0
 
template<typename T >
const bool blaze_is_numeric = blaze::IsNumeric_v<T>
 
template<typename T >
const bool blaze_is_numeric_v = blaze_is_numeric<T>
 

Detailed Description

Defines class PointerVector.

Macro Definition Documentation

◆ MAKE_MATH_ASSIGN_EXPRESSION_POINTERVECTOR

#define MAKE_MATH_ASSIGN_EXPRESSION_POINTERVECTOR (   OP,
  TYPE 
)
Value:
TYPE& operator OP(const TYPE& rhs) noexcept { \
/* clang-tidy: parens around OP */ \
~*this OP ~rhs; /* NOLINT */ \
return *this; \
} \
/* clang-tidy: parens around TYPE */ \
template <typename VT, bool VF> \
TYPE& operator OP(const blaze::DenseVector<VT, VF>& rhs) /* NOLINT */ \
noexcept { \
~*this OP rhs; \
return *this; \
} \
/* clang-tidy: parens around TYPE */ \
TYPE& operator OP(const ElementType& rhs) noexcept { /* NOLINT */ \
~*this OP rhs; \
return *this; \
}

Generates the OP assignment operator for the type TYPE

For example, if OP is += and TYPE is DataVector then this will add += for DataVector on the RHS, blaze::DenseVector on the RHS, and ElementType (double for DataVector) on the RHS. This macro is used in the cases where the new vector type inherits from PointerVector with a custom ExprResultType.