Simple C-Array Operations

Basic operations for compile-time fixed length arrays. More...


Classes

struct  PHX::Op::Copy< T, n, n >
struct  PHX::Op::Sum< T, n, n >
struct  PHX::Op::Prod< T, n, n >
struct  PHX::Op::Max< T, n, n >
struct  PHX::Op::Min< T, n, n >
struct  PHX::Op::BitOr< T, n, n >
struct  PHX::Op::BitAnd< T, n, n >
struct  PHX::Op::Equal< T, n, n >
struct  PHX::Op::NotEqual< T, n, n >
struct  PHX::Op::InnerProduct< T, n, n >
struct  PHX::Op::Less< T, n, n >
struct  PHX::Op::LessEqual< T, n, n >
struct  PHX::Op::Greater< T, n, n >
struct  PHX::Op::GreaterEqual< T, n, n >
struct  PHX::Op::Copy< T, n, i >
struct  PHX::Op::Sum< T, n, i >
struct  PHX::Op::Prod< T, n, i >
struct  PHX::Op::BitOr< T, n, i >
struct  PHX::Op::BitAnd< T, n, i >
struct  PHX::Op::Max< T, n, i >
struct  PHX::Op::Min< T, n, i >
struct  PHX::Op::InnerProduct< T, n, i >
struct  PHX::Op::Equal< T, n, i >
struct  PHX::Op::NotEqual< T, n, i >
struct  PHX::Op::Less< T, n, i >
struct  PHX::Op::LessEqual< T, n, i >
struct  PHX::Op::Greater< T, n, i >
struct  PHX::Op::GreaterEqual< T, n, i >

Enumerations

enum  { PHX::Op::Copy< T, n, n >::N = 0 }
enum  { PHX::Op::Sum< T, n, n >::N = 0 }
enum  { PHX::Op::Prod< T, n, n >::N = 0 }
enum  { PHX::Op::Max< T, n, n >::N = 0 }
enum  { PHX::Op::Min< T, n, n >::N = 0 }
enum  { PHX::Op::BitOr< T, n, n >::N = 0 }
enum  { PHX::Op::BitAnd< T, n, n >::N = 0 }
enum  { PHX::Op::Copy::N = n }
enum  { PHX::Op::Sum::N = n }
enum  { PHX::Op::Prod::N = n }
enum  { PHX::Op::BitOr::N = n }
enum  { PHX::Op::BitAnd::N = n }
enum  { PHX::Op::Max::N = n }
enum  { PHX::Op::Min::N = n }

Functions

template<unsigned N, typename T >
void PHX::Copy (T *, const T &)
template<unsigned N, typename T >
void PHX::Copy (T *, const T *)
template<unsigned N, typename T >
void PHX::Sum (T *, const T *)
template<unsigned N, typename T >
void PHX::Sum (T *, const T &, const T *)
template<unsigned N, typename T >
void PHX::Prod (T *, const T *)
template<unsigned N, typename T >
void PHX::Min (T *, const T *)
template<unsigned N, typename T >
void PHX::Max (T *, const T *)
template<unsigned N, typename T >
void PHX::BitOr (T *, const T *)
template<unsigned N, typename T >
void PHX::BitAnd (T *, const T *)
template<unsigned N, typename T >
T PHX::InnerProduct (const T *, const T *)
template<unsigned N, typename T >
bool PHX::Equal (const T *, const T *)
template<unsigned N, typename T >
bool PHX::NotEqual (const T *, const T *)
template<unsigned N, typename T >
bool PHX::Less (const T *, const T *)
template<unsigned N, typename T >
bool PHX::LessEqual (const T *, const T *)
template<unsigned N, typename T >
bool PHX::Greater (const T *, const T *)
template<unsigned N, typename T >
bool PHX::GreaterEqual (const T *, const T *)
static void PHX::Op::Copy< T, n, n >::op (T *, const T *)
static void PHX::Op::Copy< T, n, n >::op (T *, const T &)
 PHX::Op::Copy< T, n, n >::Copy ()
 PHX::Op::Copy< T, n, n >::Copy (T *p)
 PHX::Op::Copy< T, n, n >::Copy (const Copy &rhs)
Copy & PHX::Op::Copy< T, n, n >::operator= (const Copy &rhs)
static void PHX::Op::Sum< T, n, n >::op (T *, const T *)
static void PHX::Op::Sum< T, n, n >::op (T *, const T &, const T *)
 PHX::Op::Sum< T, n, n >::Sum ()
 PHX::Op::Sum< T, n, n >::Sum (T *p)
 PHX::Op::Sum< T, n, n >::Sum (const Sum &rhs)
Sum & PHX::Op::Sum< T, n, n >::operator= (const Sum &rhs)
static void PHX::Op::Prod< T, n, n >::op (T *, const T *)
 PHX::Op::Prod< T, n, n >::Prod ()
 PHX::Op::Prod< T, n, n >::Prod (T *p)
 PHX::Op::Prod< T, n, n >::Prod (const Prod &rhs)
Prod & PHX::Op::Prod< T, n, n >::operator= (const Prod &rhs)
static void PHX::Op::Max< T, n, n >::op (T *, const T *)
 PHX::Op::Max< T, n, n >::Max ()
 PHX::Op::Max< T, n, n >::Max (T *p)
 PHX::Op::Max< T, n, n >::Max (const Max &rhs)
Max & PHX::Op::Max< T, n, n >::operator= (const Max &rhs)
static void PHX::Op::Min< T, n, n >::op (T *, const T *)
 PHX::Op::Min< T, n, n >::Min ()
 PHX::Op::Min< T, n, n >::Min (T *p)
 PHX::Op::Min< T, n, n >::Min (const Min &rhs)
Min & PHX::Op::Min< T, n, n >::operator= (const Min &rhs)
static void PHX::Op::BitOr< T, n, n >::op (T *, const T *)
 PHX::Op::BitOr< T, n, n >::BitOr ()
 PHX::Op::BitOr< T, n, n >::BitOr (T *p)
 PHX::Op::BitOr< T, n, n >::BitOr (const BitOr &rhs)
BitOr & PHX::Op::BitOr< T, n, n >::operator= (const BitOr &rhs)
static void PHX::Op::BitAnd< T, n, n >::op (T *, const T *)
 PHX::Op::BitAnd< T, n, n >::BitAnd ()
 PHX::Op::BitAnd< T, n, n >::BitAnd (T *p)
 PHX::Op::BitAnd< T, n, n >::BitAnd (const BitAnd &rhs)
BitAnd & PHX::Op::BitAnd< T, n, n >::operator= (const BitAnd &rhs)
static void PHX::Op::Copy::op (T *dst, const T *src)
static void PHX::Op::Copy::op (T *dst, const T &src)
 PHX::Op::Copy::Copy ()
 PHX::Op::Copy::Copy (T *p)
 PHX::Op::Copy::Copy (const Copy &rhs)
Copy & PHX::Op::Copy::operator= (const Copy &rhs)
static void PHX::Op::Sum::op (T *dst, const T *src)
static void PHX::Op::Sum::op (T *dst, const T &a, const T *src)
 PHX::Op::Sum::Sum ()
 PHX::Op::Sum::Sum (T *p)
 PHX::Op::Sum::Sum (const Sum &rhs)
Sum & PHX::Op::Sum::operator= (const Sum &rhs)
static void PHX::Op::Prod::op (T *dst, const T *src)
 PHX::Op::Prod::Prod ()
 PHX::Op::Prod::Prod (T *p)
 PHX::Op::Prod::Prod (const Prod &rhs)
Prod & PHX::Op::Prod::operator= (const Prod &rhs)
static void PHX::Op::BitOr::op (T *dst, const T *src)
 PHX::Op::BitOr::BitOr ()
 PHX::Op::BitOr::BitOr (T *p)
 PHX::Op::BitOr::BitOr (const BitOr &rhs)
BitOr & PHX::Op::BitOr::operator= (const BitOr &rhs)
static void PHX::Op::BitAnd::op (T *dst, const T *src)
 PHX::Op::BitAnd::BitAnd ()
 PHX::Op::BitAnd::BitAnd (T *p)
 PHX::Op::BitAnd::BitAnd (const BitAnd &rhs)
BitAnd & PHX::Op::BitAnd::operator= (const BitAnd &rhs)
static void PHX::Op::Max::op (T *dst, const T *src)
 PHX::Op::Max::Max ()
 PHX::Op::Max::Max (T *p)
 PHX::Op::Max::Max (const Max &rhs)
Max & PHX::Op::Max::operator= (const Max &rhs)
static void PHX::Op::Min::op (T *dst, const T *src)
 PHX::Op::Min::Min ()
 PHX::Op::Min::Min (T *p)
 PHX::Op::Min::Min (const Min &rhs)
Min & PHX::Op::Min::operator= (const Min &rhs)
template<unsigned N, typename T >
Op::Copy< T, N > PHX::Copy (T *dst)
template<unsigned N, typename T >
Op::Sum< T, N > PHX::Sum (T *dst)
template<unsigned N, typename T >
Op::Prod< T, N > PHX::Prod (T *dst)
template<unsigned N, typename T >
Op::Max< T, N > PHX::Max (T *dst)
template<unsigned N, typename T >
Op::Min< T, N > PHX::Min (T *dst)
template<unsigned N, typename T >
Op::BitOr< T, N > PHX::BitOr (T *dst)
template<unsigned N, typename T >
Op::BitAnd< T, N > PHX::BitAnd (T *dst)

Variables

T * PHX::Op::Copy< T, n, n >::ptr
T * PHX::Op::Sum< T, n, n >::ptr
T * PHX::Op::Prod< T, n, n >::ptr
T * PHX::Op::Max< T, n, n >::ptr
T * PHX::Op::Min< T, n, n >::ptr
T * PHX::Op::BitOr< T, n, n >::ptr
T * PHX::Op::BitAnd< T, n, n >::ptr
T * PHX::Op::Copy::ptr
T * PHX::Op::Sum::ptr
T * PHX::Op::Prod::ptr
T * PHX::Op::BitOr::ptr
T * PHX::Op::BitAnd::ptr
T * PHX::Op::Max::ptr
T * PHX::Op::Min::ptr

Detailed Description

Basic operations for compile-time fixed length arrays.

Author:
H. Carter Edwards <hcedwar@sandia.gov>
Date:
November 2006
Example: Sum<5>(x,y) results in x[i] += y[i] for i=0..4

Enumeration Type Documentation

template<typename T , unsigned n>
anonymous enum [inherited]

Enumerator:
N 

template<typename T , unsigned n>
anonymous enum [inherited]

Enumerator:
N 

template<typename T , unsigned n>
anonymous enum [inherited]

Enumerator:
N 

template<typename T , unsigned n>
anonymous enum [inherited]

Enumerator:
N 

template<typename T , unsigned n>
anonymous enum [inherited]

Enumerator:
N 

template<typename T , unsigned n>
anonymous enum [inherited]

Enumerator:
N 

template<typename T , unsigned n>
anonymous enum [inherited]

Enumerator:
N 

template<typename T , unsigned n, unsigned i>
anonymous enum [inherited]

Enumerator:
N 

template<typename T , unsigned n, unsigned i>
anonymous enum [inherited]

Enumerator:
N 

template<typename T , unsigned n, unsigned i>
anonymous enum [inherited]

Enumerator:
N 

template<typename T , unsigned n, unsigned i>
anonymous enum [inherited]

Enumerator:
N 

template<typename T , unsigned n, unsigned i>
anonymous enum [inherited]

Enumerator:
N 

template<typename T , unsigned n, unsigned i>
anonymous enum [inherited]

Enumerator:
N 

template<typename T , unsigned n, unsigned i>
anonymous enum [inherited]

Enumerator:
N 

Function Documentation

template<unsigned N, typename T >
Op::BitAnd<T,N> PHX::BitAnd ( T *  dst  )  [inline]

template<typename T , unsigned n, unsigned i>
PHX::Op::BitAnd< T, n, i >::BitAnd ( const BitAnd< T, n, i > &  rhs  )  [inline, inherited]

template<typename T , unsigned n, unsigned i>
PHX::Op::BitAnd< T, n, i >::BitAnd ( T *  p  )  [inline, inherited]

template<typename T , unsigned n, unsigned i>
PHX::Op::BitAnd< T, n, i >::BitAnd (  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::BitAnd< T, n, n >::BitAnd ( const BitAnd< T, n, n > &  rhs  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::BitAnd< T, n, n >::BitAnd ( T *  p  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::BitAnd< T, n, n >::BitAnd (  )  [inline, inherited]

template<unsigned N, typename T >
void PHX::BitAnd ( T *  dst,
const T *  src 
) [inline]

References PHX::Op::BitAnd< T, n, i >::op().

Here is the call graph for this function:

template<unsigned N, typename T >
Op::BitOr<T,N> PHX::BitOr ( T *  dst  )  [inline]

template<typename T , unsigned n, unsigned i>
PHX::Op::BitOr< T, n, i >::BitOr ( const BitOr< T, n, i > &  rhs  )  [inline, inherited]

template<typename T , unsigned n, unsigned i>
PHX::Op::BitOr< T, n, i >::BitOr ( T *  p  )  [inline, inherited]

template<typename T , unsigned n, unsigned i>
PHX::Op::BitOr< T, n, i >::BitOr (  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::BitOr< T, n, n >::BitOr ( const BitOr< T, n, n > &  rhs  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::BitOr< T, n, n >::BitOr ( T *  p  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::BitOr< T, n, n >::BitOr (  )  [inline, inherited]

template<unsigned N, typename T >
void PHX::BitOr ( T *  dst,
const T *  src 
) [inline]

References PHX::Op::BitOr< T, n, i >::op().

Here is the call graph for this function:

template<unsigned N, typename T >
Op::Copy<T,N> PHX::Copy ( T *  dst  )  [inline]

template<typename T , unsigned n, unsigned i>
PHX::Op::Copy< T, n, i >::Copy ( const Copy< T, n, i > &  rhs  )  [inline, inherited]

template<typename T , unsigned n, unsigned i>
PHX::Op::Copy< T, n, i >::Copy ( T *  p  )  [inline, inherited]

template<typename T , unsigned n, unsigned i>
PHX::Op::Copy< T, n, i >::Copy (  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::Copy< T, n, n >::Copy ( const Copy< T, n, n > &  rhs  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::Copy< T, n, n >::Copy ( T *  p  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::Copy< T, n, n >::Copy (  )  [inline, inherited]

template<unsigned N, typename T >
void PHX::Copy ( T *  dst,
const T *  src 
) [inline]

References PHX::Op::Copy< T, n, i >::op().

Here is the call graph for this function:

template<unsigned N, typename T >
void PHX::Copy ( T *  dst,
const T &  src 
) [inline]

References PHX::Op::Copy< T, n, i >::op().

Referenced by PHX::Array< Scalar, array_order, void, void, void, void, void, void, void, void >::Array(), and PHX::Array< ScalarT, Order, Cell, Node, void, void, void, void, void, void >::truncate().

Here is the call graph for this function:

Here is the caller graph for this function:

template<unsigned N, typename T >
bool PHX::Equal ( const T *  x,
const T *  y 
) [inline]

References PHX::Op::Equal< T, n, i >::op().

Here is the call graph for this function:

template<unsigned N, typename T >
bool PHX::Greater ( const T *  x,
const T *  y 
) [inline]

References PHX::Op::Greater< T, n, i >::op().

Here is the call graph for this function:

template<unsigned N, typename T >
bool PHX::GreaterEqual ( const T *  x,
const T *  y 
) [inline]

References PHX::Op::GreaterEqual< T, n, i >::op().

Here is the call graph for this function:

template<unsigned N, typename T >
T PHX::InnerProduct ( const T *  x,
const T *  y 
) [inline]

References PHX::Op::InnerProduct< T, n, i >::op().

Here is the call graph for this function:

template<unsigned N, typename T >
bool PHX::Less ( const T *  x,
const T *  y 
) [inline]

References PHX::Op::Less< T, n, i >::op().

Here is the call graph for this function:

template<unsigned N, typename T >
bool PHX::LessEqual ( const T *  x,
const T *  y 
) [inline]

References PHX::Op::LessEqual< T, n, i >::op().

Here is the call graph for this function:

template<unsigned N, typename T >
Op::Max<T,N> PHX::Max ( T *  dst  )  [inline]

template<typename T , unsigned n, unsigned i>
PHX::Op::Max< T, n, i >::Max ( const Max< T, n, i > &  rhs  )  [inline, inherited]

template<typename T , unsigned n, unsigned i>
PHX::Op::Max< T, n, i >::Max ( T *  p  )  [inline, inherited]

template<typename T , unsigned n, unsigned i>
PHX::Op::Max< T, n, i >::Max (  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::Max< T, n, n >::Max ( const Max< T, n, n > &  rhs  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::Max< T, n, n >::Max ( T *  p  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::Max< T, n, n >::Max (  )  [inline, inherited]

template<unsigned N, typename T >
void PHX::Max ( T *  dst,
const T *  src 
) [inline]

References PHX::Op::Max< T, n, i >::op().

Here is the call graph for this function:

template<unsigned N, typename T >
Op::Min<T,N> PHX::Min ( T *  dst  )  [inline]

template<typename T , unsigned n, unsigned i>
PHX::Op::Min< T, n, i >::Min ( const Min< T, n, i > &  rhs  )  [inline, inherited]

template<typename T , unsigned n, unsigned i>
PHX::Op::Min< T, n, i >::Min ( T *  p  )  [inline, inherited]

template<typename T , unsigned n, unsigned i>
PHX::Op::Min< T, n, i >::Min (  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::Min< T, n, n >::Min ( const Min< T, n, n > &  rhs  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::Min< T, n, n >::Min ( T *  p  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::Min< T, n, n >::Min (  )  [inline, inherited]

template<unsigned N, typename T >
void PHX::Min ( T *  dst,
const T *  src 
) [inline]

References PHX::Op::Min< T, n, i >::op().

Here is the call graph for this function:

template<unsigned N, typename T >
bool PHX::NotEqual ( const T *  x,
const T *  y 
) [inline]

References PHX::Op::NotEqual< T, n, i >::op().

Here is the call graph for this function:

template<typename T , unsigned n, unsigned i>
static void PHX::Op::Min< T, n, i >::op ( T *  dst,
const T *  src 
) [inline, static, inherited]

Referenced by PHX::Min().

Here is the caller graph for this function:

template<typename T , unsigned n, unsigned i>
static void PHX::Op::Max< T, n, i >::op ( T *  dst,
const T *  src 
) [inline, static, inherited]

Referenced by PHX::Max().

Here is the caller graph for this function:

template<typename T , unsigned n, unsigned i>
static void PHX::Op::BitAnd< T, n, i >::op ( T *  dst,
const T *  src 
) [inline, static, inherited]

Referenced by PHX::BitAnd().

Here is the caller graph for this function:

template<typename T , unsigned n, unsigned i>
static void PHX::Op::BitOr< T, n, i >::op ( T *  dst,
const T *  src 
) [inline, static, inherited]

Referenced by PHX::BitOr().

Here is the caller graph for this function:

template<typename T , unsigned n, unsigned i>
static void PHX::Op::Prod< T, n, i >::op ( T *  dst,
const T *  src 
) [inline, static, inherited]

Referenced by PHX::Prod().

Here is the caller graph for this function:

template<typename T , unsigned n, unsigned i>
static void PHX::Op::Sum< T, n, i >::op ( T *  dst,
const T &  a,
const T *  src 
) [inline, static, inherited]

References PHX::Op::Sum< T, n, i >::op().

Here is the call graph for this function:

template<typename T , unsigned n, unsigned i>
static void PHX::Op::Sum< T, n, i >::op ( T *  dst,
const T *  src 
) [inline, static, inherited]

Referenced by PHX::Op::Sum< T, n, i >::op(), and PHX::Sum().

Here is the caller graph for this function:

template<typename T , unsigned n, unsigned i>
static void PHX::Op::Copy< T, n, i >::op ( T *  dst,
const T &  src 
) [inline, static, inherited]

References PHX::Op::Copy< T, n, i >::op().

Here is the call graph for this function:

template<typename T , unsigned n, unsigned i>
static void PHX::Op::Copy< T, n, i >::op ( T *  dst,
const T *  src 
) [inline, static, inherited]

Referenced by PHX::Copy(), and PHX::Op::Copy< T, n, i >::op().

Here is the caller graph for this function:

template<typename T , unsigned n>
static void PHX::Op::BitAnd< T, n, n >::op ( T *  ,
const T *   
) [inline, static, inherited]

template<typename T , unsigned n>
static void PHX::Op::BitOr< T, n, n >::op ( T *  ,
const T *   
) [inline, static, inherited]

template<typename T , unsigned n>
static void PHX::Op::Min< T, n, n >::op ( T *  ,
const T *   
) [inline, static, inherited]

template<typename T , unsigned n>
static void PHX::Op::Max< T, n, n >::op ( T *  ,
const T *   
) [inline, static, inherited]

template<typename T , unsigned n>
static void PHX::Op::Prod< T, n, n >::op ( T *  ,
const T *   
) [inline, static, inherited]

template<typename T , unsigned n>
static void PHX::Op::Sum< T, n, n >::op ( T *  ,
const T &  ,
const T *   
) [inline, static, inherited]

template<typename T , unsigned n>
static void PHX::Op::Sum< T, n, n >::op ( T *  ,
const T *   
) [inline, static, inherited]

template<typename T , unsigned n>
static void PHX::Op::Copy< T, n, n >::op ( T *  ,
const T &   
) [inline, static, inherited]

template<typename T , unsigned n>
static void PHX::Op::Copy< T, n, n >::op ( T *  ,
const T *   
) [inline, static, inherited]

template<typename T , unsigned n, unsigned i>
Min& PHX::Op::Min< T, n, i >::operator= ( const Min< T, n, i > &  rhs  )  [inline, inherited]

References PHX::Op::Min< T, n, i >::ptr.

template<typename T , unsigned n, unsigned i>
Max& PHX::Op::Max< T, n, i >::operator= ( const Max< T, n, i > &  rhs  )  [inline, inherited]

References PHX::Op::Max< T, n, i >::ptr.

template<typename T , unsigned n, unsigned i>
BitAnd& PHX::Op::BitAnd< T, n, i >::operator= ( const BitAnd< T, n, i > &  rhs  )  [inline, inherited]

References PHX::Op::BitAnd< T, n, i >::ptr.

template<typename T , unsigned n, unsigned i>
BitOr& PHX::Op::BitOr< T, n, i >::operator= ( const BitOr< T, n, i > &  rhs  )  [inline, inherited]

References PHX::Op::BitOr< T, n, i >::ptr.

template<typename T , unsigned n, unsigned i>
Prod& PHX::Op::Prod< T, n, i >::operator= ( const Prod< T, n, i > &  rhs  )  [inline, inherited]

References PHX::Op::Prod< T, n, i >::ptr.

template<typename T , unsigned n, unsigned i>
Sum& PHX::Op::Sum< T, n, i >::operator= ( const Sum< T, n, i > &  rhs  )  [inline, inherited]

References PHX::Op::Sum< T, n, i >::ptr.

template<typename T , unsigned n, unsigned i>
Copy& PHX::Op::Copy< T, n, i >::operator= ( const Copy< T, n, i > &  rhs  )  [inline, inherited]

References PHX::Op::Copy< T, n, i >::ptr.

template<typename T , unsigned n>
BitAnd& PHX::Op::BitAnd< T, n, n >::operator= ( const BitAnd< T, n, n > &  rhs  )  [inline, inherited]

References PHX::Op::BitAnd< T, n, i >::ptr.

template<typename T , unsigned n>
BitOr& PHX::Op::BitOr< T, n, n >::operator= ( const BitOr< T, n, n > &  rhs  )  [inline, inherited]

References PHX::Op::BitOr< T, n, i >::ptr.

template<typename T , unsigned n>
Min& PHX::Op::Min< T, n, n >::operator= ( const Min< T, n, n > &  rhs  )  [inline, inherited]

References PHX::Op::Min< T, n, i >::ptr.

template<typename T , unsigned n>
Max& PHX::Op::Max< T, n, n >::operator= ( const Max< T, n, n > &  rhs  )  [inline, inherited]

References PHX::Op::Max< T, n, i >::ptr.

template<typename T , unsigned n>
Prod& PHX::Op::Prod< T, n, n >::operator= ( const Prod< T, n, n > &  rhs  )  [inline, inherited]

References PHX::Op::Prod< T, n, i >::ptr.

template<typename T , unsigned n>
Sum& PHX::Op::Sum< T, n, n >::operator= ( const Sum< T, n, n > &  rhs  )  [inline, inherited]

References PHX::Op::Sum< T, n, i >::ptr.

template<typename T , unsigned n>
Copy& PHX::Op::Copy< T, n, n >::operator= ( const Copy< T, n, n > &  rhs  )  [inline, inherited]

References PHX::Op::Copy< T, n, i >::ptr.

template<unsigned N, typename T >
Op::Prod<T,N> PHX::Prod ( T *  dst  )  [inline]

template<typename T , unsigned n, unsigned i>
PHX::Op::Prod< T, n, i >::Prod ( const Prod< T, n, i > &  rhs  )  [inline, inherited]

template<typename T , unsigned n, unsigned i>
PHX::Op::Prod< T, n, i >::Prod ( T *  p  )  [inline, inherited]

template<typename T , unsigned n, unsigned i>
PHX::Op::Prod< T, n, i >::Prod (  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::Prod< T, n, n >::Prod ( const Prod< T, n, n > &  rhs  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::Prod< T, n, n >::Prod ( T *  p  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::Prod< T, n, n >::Prod (  )  [inline, inherited]

template<unsigned N, typename T >
void PHX::Prod ( T *  dst,
const T *  src 
) [inline]

References PHX::Op::Prod< T, n, i >::op().

Here is the call graph for this function:

template<unsigned N, typename T >
Op::Sum<T,N> PHX::Sum ( T *  dst  )  [inline]

template<typename T , unsigned n, unsigned i>
PHX::Op::Sum< T, n, i >::Sum ( const Sum< T, n, i > &  rhs  )  [inline, inherited]

template<typename T , unsigned n, unsigned i>
PHX::Op::Sum< T, n, i >::Sum ( T *  p  )  [inline, inherited]

template<typename T , unsigned n, unsigned i>
PHX::Op::Sum< T, n, i >::Sum (  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::Sum< T, n, n >::Sum ( const Sum< T, n, n > &  rhs  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::Sum< T, n, n >::Sum ( T *  p  )  [inline, inherited]

template<typename T , unsigned n>
PHX::Op::Sum< T, n, n >::Sum (  )  [inline, inherited]

template<unsigned N, typename T >
void PHX::Sum ( T *  dst,
const T &  a,
const T *  src 
) [inline]

References PHX::Op::Sum< T, n, i >::op().

Here is the call graph for this function:

template<unsigned N, typename T >
void PHX::Sum ( T *  dst,
const T *  src 
) [inline]

References PHX::Op::Sum< T, n, i >::op().

Here is the call graph for this function:

Variable Documentation

template<typename T , unsigned n, unsigned i>
T* PHX::Op::Min< T, n, i >::ptr [inherited]

Referenced by PHX::Op::Min< T, n, i >::operator=(), and PHX::Op::Min< T, n, n >::operator=().

template<typename T , unsigned n, unsigned i>
T* PHX::Op::Max< T, n, i >::ptr [inherited]

Referenced by PHX::Op::Max< T, n, i >::operator=(), and PHX::Op::Max< T, n, n >::operator=().

template<typename T , unsigned n, unsigned i>
T* PHX::Op::BitAnd< T, n, i >::ptr [inherited]

Referenced by PHX::Op::BitAnd< T, n, i >::operator=(), and PHX::Op::BitAnd< T, n, n >::operator=().

template<typename T , unsigned n, unsigned i>
T* PHX::Op::BitOr< T, n, i >::ptr [inherited]

Referenced by PHX::Op::BitOr< T, n, i >::operator=(), and PHX::Op::BitOr< T, n, n >::operator=().

template<typename T , unsigned n, unsigned i>
T* PHX::Op::Prod< T, n, i >::ptr [inherited]

Referenced by PHX::Op::Prod< T, n, i >::operator=(), and PHX::Op::Prod< T, n, n >::operator=().

template<typename T , unsigned n, unsigned i>
T* PHX::Op::Sum< T, n, i >::ptr [inherited]

Referenced by PHX::Op::Sum< T, n, i >::operator=(), and PHX::Op::Sum< T, n, n >::operator=().

template<typename T , unsigned n, unsigned i>
T* PHX::Op::Copy< T, n, i >::ptr [inherited]

Referenced by PHX::Op::Copy< T, n, i >::operator=(), and PHX::Op::Copy< T, n, n >::operator=().

template<typename T , unsigned n>
T* PHX::Op::BitAnd< T, n, n >::ptr [inherited]

template<typename T , unsigned n>
T* PHX::Op::BitOr< T, n, n >::ptr [inherited]

template<typename T , unsigned n>
T* PHX::Op::Min< T, n, n >::ptr [inherited]

template<typename T , unsigned n>
T* PHX::Op::Max< T, n, n >::ptr [inherited]

template<typename T , unsigned n>
T* PHX::Op::Prod< T, n, n >::ptr [inherited]

template<typename T , unsigned n>
T* PHX::Op::Sum< T, n, n >::ptr [inherited]

template<typename T , unsigned n>
T* PHX::Op::Copy< T, n, n >::ptr [inherited]

Generated on Wed Oct 21 14:31:14 2009 for Phalanx by  doxygen 1.5.9