array.h File Reference

#include "features/compilerfeatures.h"
#include "features/sse.h"
#include <stddef.h>
#include <algorithm>
#include <stdexcept>
#include <iterator>
#include <limits>
#include <iostream>

Include dependency graph for array.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	r123array1x32
struct	r123array2x32
struct	r123array4x32
struct	r123array8x32
struct	r123array1x64
struct	r123array2x64
struct	r123array4x64
struct	r123array16x8
struct	r123array1xm128i

Namespaces
	r123

Macros
#define	CXXMETHODS_REQUIRING_STL
#define	CXXMETHODS(_N, W, T)
#define	CXXOVERLOADS(_N, W, T)
#define	_r123array_tpl(_N, W, T)
#define	R123_W(a)   (8*sizeof(((a *)0)->v[0]))

Typedefs
typedef r123array1x32	r123::Array1x32
typedef r123array2x32	r123::Array2x32
typedef r123array4x32	r123::Array4x32
typedef r123array8x32	r123::Array8x32
typedef r123array1x64	r123::Array1x64
typedef r123array2x64	r123::Array2x64
typedef r123array4x64	r123::Array4x64
typedef r123array16x8	r123::Array16x8
typedef r123array1xm128i	r123::Array1xm128i

Functions
std::ostream &	operator<< (std::ostream &os, const r123array1x32 &a)
std::istream &	operator>> (std::istream &is, r123array1x32 &a)
std::ostream &	operator<< (std::ostream &os, const r123array2x32 &a)
std::istream &	operator>> (std::istream &is, r123array2x32 &a)
std::ostream &	operator<< (std::ostream &os, const r123array4x32 &a)
std::istream &	operator>> (std::istream &is, r123array4x32 &a)
std::ostream &	operator<< (std::ostream &os, const r123array8x32 &a)
std::istream &	operator>> (std::istream &is, r123array8x32 &a)
std::ostream &	operator<< (std::ostream &os, const r123array1x64 &a)
std::istream &	operator>> (std::istream &is, r123array1x64 &a)
std::ostream &	operator<< (std::ostream &os, const r123array2x64 &a)
std::istream &	operator>> (std::istream &is, r123array2x64 &a)
std::ostream &	operator<< (std::ostream &os, const r123array4x64 &a)
std::istream &	operator>> (std::istream &is, r123array4x64 &a)
std::ostream &	operator<< (std::ostream &os, const r123array16x8 &a)
std::istream &	operator>> (std::istream &is, r123array16x8 &a)
std::ostream &	operator<< (std::ostream &os, const r123array1xm128i &a)
std::istream &	operator>> (std::istream &is, r123array1xm128i &a)

Macro Definition Documentation

_r123array_tpl

#define _r123array_tpl	(		_N,
			W,
			T
	)

Value:

                        \                            \
struct r123array##_N##x##W{                         \
 T v[_N];                                       \
 CXXMETHODS(_N, W, T)                           \
 CXXMETHODS_REQUIRING_STL                       \
};                                              \
                                                \
CXXOVERLOADS(_N, W, T)

CXXMETHODS

#define CXXMETHODS	(		_N,
			W,
			T
	)

CXXMETHODS_REQUIRING_STL

#define CXXMETHODS_REQUIRING_STL

Value:

    public: \
    typedef std::reverse_iterator<iterator> reverse_iterator;           \
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator; \
    R123_CUDA_DEVICE reverse_iterator rbegin(){ return reverse_iterator(end()); }                         \
    R123_CUDA_DEVICE const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); } \
    R123_CUDA_DEVICE reverse_iterator rend(){ return reverse_iterator(begin()); }        \
    R123_CUDA_DEVICE const_reverse_iterator rend() const{ return const_reverse_iterator(begin()); } \
    R123_CUDA_DEVICE const_reverse_iterator crbegin() const{ return const_reverse_iterator(cend()); } \
    R123_CUDA_DEVICE const_reverse_iterator crend() const{ return const_reverse_iterator(cbegin()); }

CXXOVERLOADS

#define CXXOVERLOADS	(		_N,
			W,
			T
	)

Value:

                                                                        \
inline std::ostream& operator<<(std::ostream& os, const r123array##_N##x##W& a){   \
    os << r123arrayinsertable<T>(a.v[0]);                                  \
    for(size_t i=1; i<_N; ++i)                                          \
        os << " " << r123arrayinsertable<T>(a.v[i]);                       \
    return os;                                                          \
}                                                                       \
                                                                        \
inline std::istream& operator>>(std::istream& is, r123array##_N##x##W& a){         \
    for(size_t i=0; i<_N; ++i){                                         \
        r123arrayextractable<T> x(a.v[i]);                                 \
        is >> x;                                                        \
    }                                                                   \
    return is;                                                          \
}                                                                       \
                                                                        \
namespace r123{                                                        \
 typedef r123array##_N##x##W Array##_N##x##W;                          \
}

R123_W

#define R123_W

(

a

)

(8*sizeof(((a *)0)->v[0]))

Function Documentation

operator<<() [1/9]

std::ostream& operator<< ( std::ostream &  os, const r123array16x8 &  a  )

inline

operator<<() [2/9]

std::ostream& operator<< ( std::ostream &  os, const r123array1x32 &  a  )

inline

operator<<() [3/9]

std::ostream& operator<< ( std::ostream &  os, const r123array1x64 &  a  )

inline

operator<<() [4/9]

std::ostream& operator<< ( std::ostream &  os, const r123array1xm128i &  a  )

inline

operator<<() [5/9]

std::ostream& operator<< ( std::ostream &  os, const r123array2x32 &  a  )

inline

operator<<() [6/9]

std::ostream& operator<< ( std::ostream &  os, const r123array2x64 &  a  )

inline

operator<<() [7/9]

std::ostream& operator<< ( std::ostream &  os, const r123array4x32 &  a  )

inline

operator<<() [8/9]

std::ostream& operator<< ( std::ostream &  os, const r123array4x64 &  a  )

inline

operator<<() [9/9]

std::ostream& operator<< ( std::ostream &  os, const r123array8x32 &  a  )

inline

operator>>() [1/9]

std::istream& operator>> ( std::istream &  is, r123array16x8 &  a  )

inline

operator>>() [2/9]

std::istream& operator>> ( std::istream &  is, r123array1x32 &  a  )

inline

operator>>() [3/9]

std::istream& operator>> ( std::istream &  is, r123array1x64 &  a  )

inline

operator>>() [4/9]

std::istream& operator>> ( std::istream &  is, r123array1xm128i &  a  )

inline

operator>>() [5/9]

std::istream& operator>> ( std::istream &  is, r123array2x32 &  a  )

inline

operator>>() [6/9]

std::istream& operator>> ( std::istream &  is, r123array2x64 &  a  )

inline

operator>>() [7/9]

std::istream& operator>> ( std::istream &  is, r123array4x32 &  a  )

inline

operator>>() [8/9]

std::istream& operator>> ( std::istream &  is, r123array4x64 &  a  )

inline

operator>>() [9/9]

std::istream& operator>> ( std::istream &  is, r123array8x32 &  a  )

inline