doxygen/stormm__vector__types_8h_source.html

// -*-c++-*-

#ifndef STORMM_VECTOR_TYPES_H

#define STORMM_VECTOR_TYPES_H


#include <cstddef>

#include <typeinfo>

#include <typeindex>

#include <vector>

#ifdef STORMM_USE_HPC

#include <vector_types.h>

#endif

#include "copyright.h"

#include "Reporting/error_format.h"

#include "common_types.h"


namespace stormm {

namespace data_types {


#ifndef STORMM_USE_HPC

// If CUDA is not defined, then some of the CUDA POD vector types will need to be delineated in

// order to run the program in CPU code.


struct int2 {

  int x;

  int y;

};


struct int3 {

  int x;

  int y;

  int z;

};


struct int4 {

  int x;

  int y;

  int z;

  int w;

};


struct uint2 {

  unsigned int x;

  unsigned int y;

};


struct uint3 {

  unsigned int x;

  unsigned int y;

  unsigned int z;

};


struct uint4 {

  unsigned int x;

  unsigned int y;

  unsigned int z;

  unsigned int w;

};


struct float2 {

  float x;

  float y;

};


struct float3 {

  float x;

  float y;

  float z;

};


struct float4 {

  float x;

  float y;

  float z;

  float w;

};


struct longlong2 {

  long long int x;

  long long int y;

};


struct longlong3 {

  long long int x;

  long long int y;

  long long int z;

};


struct longlong4 {

  long long int x;

  long long int y;

  long long int z;

  long long int w;

};


struct ulonglong2 {

  unsigned long long int x;

  unsigned long long int y;

};


struct ulonglong3 {

  unsigned long long int x;

  unsigned long long int y;

  unsigned long long int z;

};


struct ulonglong4 {

  unsigned long long int x;

  unsigned long long int y;

  unsigned long long int z;

  unsigned long long int w;

};


struct double2 {

  double x;

  double y;

};


struct double3 {

  double x;

  double y;

  double z;

};


struct double4 {

  double x;

  double y;

  double z;

  double w;

};


struct char2 {

  char x;

  char y;

};


struct char3 {

  char x;

  char y;

  char z;

};


struct char4 {

  char x;

  char y;

  char z;

  char w;

};


struct uchar2 {

  unsigned char x;

  unsigned char y;

};


struct uchar3 {

  unsigned char x;

  unsigned char y;

  unsigned char z;

};


struct uchar4 {

  unsigned char x;

  unsigned char y;

  unsigned char z;

  unsigned char w;

};


struct short2 {

  short int x;

  short int y;

};


struct short3 {

  short int x;

  short int y;

  short int z;

};


struct short4 {

  short int x;

  short int y;

  short int z;

  short int w;

};


struct ushort2 {

  unsigned short int x;

  unsigned short int y;

};


struct ushort3 {

  unsigned short int x;

  unsigned short int y;

  unsigned short int z;

};


struct ushort4 {

  unsigned short int x;

  unsigned short int y;

  unsigned short int z;

  unsigned short int w;

};


#endif


// Type definitions for consistent nomenclature

typedef longlong2 llint2;

typedef longlong3 llint3;

typedef longlong4 llint4;

typedef ulonglong2 ullint2;

typedef ulonglong3 ullint3;

typedef ulonglong4 ullint4;


// CUDA- and HIP-defined vector types corresponding to each of the above POD types

static const size_t int2_type_index = std::type_index(typeid(int2)).hash_code();

static const size_t int3_type_index = std::type_index(typeid(int3)).hash_code();

static const size_t int4_type_index = std::type_index(typeid(int4)).hash_code();

static const size_t double2_type_index = std::type_index(typeid(double2)).hash_code();

static const size_t double3_type_index = std::type_index(typeid(double3)).hash_code();

static const size_t double4_type_index = std::type_index(typeid(double4)).hash_code();

static const size_t float2_type_index = std::type_index(typeid(float2)).hash_code();

static const size_t float3_type_index = std::type_index(typeid(float3)).hash_code();

static const size_t float4_type_index = std::type_index(typeid(float4)).hash_code();

static const size_t char2_type_index = std::type_index(typeid(char2)).hash_code();

static const size_t char3_type_index = std::type_index(typeid(char3)).hash_code();

static const size_t char4_type_index = std::type_index(typeid(char4)).hash_code();

static const size_t uchar2_type_index = std::type_index(typeid(uchar2)).hash_code();

static const size_t uchar3_type_index = std::type_index(typeid(uchar3)).hash_code();

static const size_t uchar4_type_index = std::type_index(typeid(uchar4)).hash_code();

static const size_t uint2_type_index = std::type_index(typeid(uint2)).hash_code();

static const size_t uint3_type_index = std::type_index(typeid(uint3)).hash_code();

static const size_t uint4_type_index = std::type_index(typeid(uint4)).hash_code();

static const size_t longlong2_type_index = std::type_index(typeid(longlong2)).hash_code();

static const size_t longlong3_type_index = std::type_index(typeid(longlong3)).hash_code();

static const size_t longlong4_type_index = std::type_index(typeid(longlong4)).hash_code();

static const size_t ulonglong2_type_index = std::type_index(typeid(ulonglong2)).hash_code();

static const size_t ulonglong3_type_index = std::type_index(typeid(ulonglong3)).hash_code();

static const size_t ulonglong4_type_index = std::type_index(typeid(ulonglong4)).hash_code();

static const size_t short2_type_index = std::type_index(typeid(short2)).hash_code();

static const size_t short3_type_index = std::type_index(typeid(short3)).hash_code();

static const size_t short4_type_index = std::type_index(typeid(short4)).hash_code();

static const size_t ushort2_type_index = std::type_index(typeid(ushort2)).hash_code();

static const size_t ushort3_type_index = std::type_index(typeid(ushort3)).hash_code();

static const size_t ushort4_type_index = std::type_index(typeid(ushort4)).hash_code();


template <typename T> bool isHpcVectorType();


template <typename T> bool isSignedIntegralHpcVectorType();


template <typename T> bool isUnsignedIntegralHpcVectorType();


template <typename T> bool isFloatingPointHpcVectorType();


template <typename T> int getHpcVectorTypeSize();


template <typename T> std::string getStormmHpcVectorTypeName();


struct int95_t {

  long long int x;

  int y;

};


// Also define the fixed-precision type for 95-bit storage of double-precision numbers.

static const size_t int95t_type_index = std::type_index(typeid(int95_t)).hash_code();


template <typename T> struct Vec2 {


  explicit Vec2(T x_in, T y_in);

  template <typename Tinput> Vec2(const Tinput v_in);


  // Public member variables

  T x;

  T y;

};


template <typename T> struct Vec3 {


  explicit Vec3(T x_in, T y_in, T z_in);

  template <typename Tinput> Vec3(const Tinput v_in);


  T x;

  T y;

  T z;

};


template <typename T> struct Vec4 {


  explicit Vec4(T x_in, T y_in, T z_in, T w_in);

  template <typename Tinput> Vec4(const Tinput v_in);


  T x;

  T y;

  T z;

  T w;

};


template <typename T> double2 vtConv2(const T rhs);

template <typename T> double3 vtConv3(const T rhs);

template <typename T> double4 vtConv4(const T rhs);

template <typename T> float2 vtConv2f(const T rhs);

template <typename T> float3 vtConv3f(const T rhs);

template <typename T> float4 vtConv4f(const T rhs);

template <typename T> std::vector<double2> vtConv2(const std::vector<T> &rhs);

template <typename T> std::vector<double3> vtConv3(const std::vector<T> &rhs);

template <typename T> std::vector<double4> vtConv4(const std::vector<T> &rhs);

template <typename T> std::vector<float2> vtConv2f(const std::vector<T> &rhs);

template <typename T> std::vector<float3> vtConv3f(const std::vector<T> &rhs);

template <typename T> std::vector<float4> vtConv4f(const std::vector<T> &rhs);


uint short2ToUint(const short2 ituple);

uint ushort2ToUint(const ushort2 ituple);

uint char4ToUint(const char4 ctuple);

uint uchar4ToUint(const uchar4 ctuple);


short2 uintToShort2(const uint val);

ushort2 uintToUshort2(const uint val);

char4 uintToChar4(const uint val);

uchar4 uintToUchar4(const uint val);


bool operator==(const short2 lhs, const short2 rhs);

bool operator!=(const short2 lhs, const short2 rhs);

bool operator==(const short3 lhs, const short3 rhs);

bool operator!=(const short3 lhs, const short3 rhs);

bool operator==(const short4 lhs, const short4 rhs);

bool operator!=(const short4 lhs, const short4 rhs);


bool operator==(const ushort2 lhs, const ushort2 rhs);

bool operator!=(const ushort2 lhs, const ushort2 rhs);

bool operator==(const ushort3 lhs, const ushort3 rhs);

bool operator!=(const ushort3 lhs, const ushort3 rhs);

bool operator==(const ushort4 lhs, const ushort4 rhs);

bool operator!=(const ushort4 lhs, const ushort4 rhs);


bool operator==(const int2 lhs, const int2 rhs);

bool operator!=(const int2 lhs, const int2 rhs);

bool operator==(const int3 lhs, const int3 rhs);

bool operator!=(const int3 lhs, const int3 rhs);

bool operator==(const int4 lhs, const int4 rhs);

bool operator!=(const int4 lhs, const int4 rhs);


bool operator==(const uint2 lhs, const uint2 rhs);

bool operator!=(const uint2 lhs, const uint2 rhs);

bool operator==(const uint3 lhs, const uint3 rhs);

bool operator!=(const uint3 lhs, const uint3 rhs);

bool operator==(const uint4 lhs, const uint4 rhs);

bool operator!=(const uint4 lhs, const uint4 rhs);


bool operator==(const llint2 lhs, const llint2 rhs);

bool operator!=(const llint2 lhs, const llint2 rhs);

bool operator==(const llint3 lhs, const llint3 rhs);

bool operator!=(const llint3 lhs, const llint3 rhs);

bool operator==(const llint4 lhs, const llint4 rhs);

bool operator!=(const llint4 lhs, const llint4 rhs);


bool operator==(const ullint2 lhs, const ullint2 rhs);

bool operator!=(const ullint2 lhs, const ullint2 rhs);

bool operator==(const ullint3 lhs, const ullint3 rhs);

bool operator!=(const ullint3 lhs, const ullint3 rhs);

bool operator==(const ullint4 lhs, const ullint4 rhs);

bool operator!=(const ullint4 lhs, const ullint4 rhs);


bool operator<(const char4 lhs, const char4 rhs);

bool operator<=(const char4 lhs, const char4 rhs);

bool operator>(const char4 lhs, const char4 rhs);

bool operator>=(const char4 lhs, const char4 rhs);

bool operator==(const char4 lhs, const char4 rhs);

bool operator!=(const char4 lhs, const char4 rhs);


union Ecumenical2 {

  short si;

  ushort usi;

  char2 c2;

  uchar2 uc2;

};


union Ecumenical4 {

  int i;

  uint ui;

  float f;

  char4 c4;

  uchar4 uc4;

};


union Ecumenical8 {

  llint lli;

  ullint ulli;

  double d;

  int2 i2;

  uint2 ui2;

  float2 f2;

};


} // namespace data_types

} // namespace stormm


#include "stormm_vector_types.tpp"


namespace stormm {


// Make the HPC vectorized tuple types available through STORMM namespaces, if they were defined

// without an overarching HPC library.

#ifndef STORMM_USE_HPC

using data_types::int2;

using data_types::int3;

using data_types::int4;

using data_types::double2;

using data_types::double3;

using data_types::double4;

using data_types::float2;

using data_types::float3;

using data_types::float4;

using data_types::char2;

using data_types::char3;

using data_types::char4;

using data_types::uchar2;

using data_types::uchar3;

using data_types::uchar4;

using data_types::uint2;

using data_types::uint3;

using data_types::uint4;

using data_types::longlong2;

using data_types::longlong3;

using data_types::longlong4;

using data_types::ulonglong2;

using data_types::ulonglong3;

using data_types::ulonglong4;

using data_types::short2;

using data_types::short3;

using data_types::short4;

using data_types::ushort2;

using data_types::ushort3;

using data_types::ushort4;

#endif


// Alternate type definitions need to be carried through regardless of HPC compilation

using data_types::llint2;

using data_types::llint3;

using data_types::llint4;

using data_types::ullint2;

using data_types::ullint3;

using data_types::ullint4;


// Also make the int95_t data type generally available by including this header file.

using data_types::int95_t;


// Make type index identifiers available in all STORMM namespaces

using data_types::int2_type_index;

using data_types::int3_type_index;

using data_types::int4_type_index;

using data_types::double2_type_index;

using data_types::double3_type_index;

using data_types::double4_type_index;

using data_types::float2_type_index;

using data_types::float3_type_index;

using data_types::float4_type_index;

using data_types::char2_type_index;

using data_types::char3_type_index;

using data_types::char4_type_index;

using data_types::uchar2_type_index;

using data_types::uchar3_type_index;

using data_types::uchar4_type_index;

using data_types::uint2_type_index;

using data_types::uint3_type_index;

using data_types::uint4_type_index;

using data_types::longlong2_type_index;

using data_types::longlong3_type_index;

using data_types::longlong4_type_index;

using data_types::ulonglong2_type_index;

using data_types::ulonglong3_type_index;

using data_types::ulonglong4_type_index;

using data_types::short2_type_index;

using data_types::short3_type_index;

using data_types::short4_type_index;

using data_types::ushort2_type_index;

using data_types::ushort3_type_index;

using data_types::ushort4_type_index;

using data_types::int95t_type_index;


// Template-compatible vector types for C++ code

using data_types::Vec2;

using data_types::Vec3;

using data_types::Vec4;


// Templated conversion functions for getting anything of the right tuple complexity into a float

// or double tuple

using data_types::vtConv2;

using data_types::vtConv3;

using data_types::vtConv4;

using data_types::vtConv2f;

using data_types::vtConv3f;

using data_types::vtConv4f;

using data_types::short2ToUint;

using data_types::ushort2ToUint;

using data_types::char4ToUint;

using data_types::uchar4ToUint;

using data_types::uintToShort2;

using data_types::uintToUshort2;

using data_types::uintToChar4;

using data_types::uintToUchar4;


using data_types::Ecumenical2;

using data_types::Ecumenical4;

using data_types::Ecumenical8;


// Overloaded assignment and comparison operators

using data_types::operator<;

using data_types::operator<=;

using data_types::operator>;

using data_types::operator>=;

using data_types::operator==;

using data_types::operator!=;


} // namespace stormm


#endif

stormm::data_types::Vec2::Vec2
Vec2(T x_in, T y_in)
Constructors will accept two scalars or one of the defined vector tuples.

stormm::data_types::Vec2::y
T y
The second member, equivalent to the y member of a float2 or longlong2 tuple.
Definition stormm_vector_types.h:287

stormm::data_types::Vec2::x
T x
The first member, equivalent to the x member of a float2 or longlong2 tuple.
Definition stormm_vector_types.h:286

stormm::data_types::Vec3::y
T y
The second member, equivalent to the y member of a double3 or uint3 tuple.
Definition stormm_vector_types.h:301

stormm::data_types::Vec3::Vec3
Vec3(T x_in, T y_in, T z_in)
Constructors will accept three scalars or one of the defined vector tuples.

stormm::data_types::Vec3::z
T z
The third member, equivalent to the z member of a double3 or uint3 tuple.
Definition stormm_vector_types.h:302

stormm::data_types::Vec3::x
T x
The first member, equivalent to the x member of a double3 or uint3 tuple.
Definition stormm_vector_types.h:300

stormm::data_types::Vec4::w
T w
The fourth member, equivalent to the w member of a float4 or int4 tuple.
Definition stormm_vector_types.h:318

stormm::data_types::Vec4::x
T x
The first member, equivalent to the x member of a float4 or int4 tuple.
Definition stormm_vector_types.h:315

stormm::data_types::Vec4::Vec4
Vec4(T x_in, T y_in, T z_in, T w_in)
Constructors will accept four scalars or one of the defined vector tuples.

stormm::data_types::Vec4::z
T z
The third member, equivalent to the z member of a float4 or int4 tuple.
Definition stormm_vector_types.h:317

stormm::data_types::Vec4::y
T y
The second member, equivalent to the y member of a float4 or int4 tuple.
Definition stormm_vector_types.h:316

stormm::data_types::char2
Definition stormm_vector_types.h:130

stormm::data_types::char3
Definition stormm_vector_types.h:135

stormm::data_types::char4
Definition stormm_vector_types.h:141

stormm::data_types::double2
Definition stormm_vector_types.h:112

stormm::data_types::double3
Definition stormm_vector_types.h:117

stormm::data_types::double4
Definition stormm_vector_types.h:123

stormm::data_types::float2
Definition stormm_vector_types.h:58

stormm::data_types::float3
Definition stormm_vector_types.h:63

stormm::data_types::float4
Definition stormm_vector_types.h:69

stormm::data_types::int2
Definition stormm_vector_types.h:22

stormm::data_types::int3
Definition stormm_vector_types.h:27

stormm::data_types::int4
Definition stormm_vector_types.h:33

stormm::data_types::int95_t
A mixed tuple for 95-bit integer accumulation. This is the proper way to take double-precision floati...
Definition stormm_vector_types.h:265

stormm::data_types::int95_t::y
int y
Overflow accumulator, used when the primary value would be exceeded.
Definition stormm_vector_types.h:269

stormm::data_types::int95_t::x
long long int x
Definition stormm_vector_types.h:266

stormm::data_types::longlong2
Definition stormm_vector_types.h:76

stormm::data_types::longlong3
Definition stormm_vector_types.h:81

stormm::data_types::longlong4
Definition stormm_vector_types.h:87

stormm::data_types::short2
Definition stormm_vector_types.h:166

stormm::data_types::short3
Definition stormm_vector_types.h:171

stormm::data_types::short4
Definition stormm_vector_types.h:177

stormm::data_types::uchar2
Definition stormm_vector_types.h:148

stormm::data_types::uchar3
Definition stormm_vector_types.h:153

stormm::data_types::uchar4
Definition stormm_vector_types.h:159

stormm::data_types::uint2
Definition stormm_vector_types.h:40

stormm::data_types::uint3
Definition stormm_vector_types.h:45

stormm::data_types::uint4
Definition stormm_vector_types.h:51

stormm::data_types::ulonglong2
Definition stormm_vector_types.h:94

stormm::data_types::ulonglong3
Definition stormm_vector_types.h:99

stormm::data_types::ulonglong4
Definition stormm_vector_types.h:105

stormm::data_types::ushort2
Definition stormm_vector_types.h:184

stormm::data_types::ushort3
Definition stormm_vector_types.h:189

stormm::data_types::ushort4
Definition stormm_vector_types.h:195

stormm::data_types::Ecumenical2
Mimic critical CUDA typecasting intrinsics with simple unions {.
Definition stormm_vector_types.h:423

stormm::data_types::Ecumenical4
Definition stormm_vector_types.h:430

stormm::data_types::Ecumenical8
Definition stormm_vector_types.h:438