blitz Version 1.0.2
Loading...
Searching...
No Matches
blitz::TinyMatrix< P_numtype, N_rows, N_columns > Class Template Reference

#include <tinymat2.h>

Inheritance diagram for blitz::TinyMatrix< P_numtype, N_rows, N_columns >:
Inheritance graph
Collaboration diagram for blitz::TinyMatrix< P_numtype, N_rows, N_columns >:
Collaboration graph

Public Types

typedef P_numtype T_numtype
 
typedef TinyVector< int, 2 > T_index
 
typedef TinyMatrix< T_numtype, N_rows, N_columnsT_matrix
 
typedef FastTM2Iterator< T_numtype, N_rows, N_columnsT_iterator
 
typedef T_numtypeiterator
 
typedef const T_numtypeconst_iterator
 
typedef FastTM2CopyIterator< P_numtype, N_rows, N_columnsT_range_result
 
- Public Types inherited from blitz::ETBase< TinyMatrix< P_numtype, N_rows, N_columns > >
typedef TinyMatrix< P_numtype, N_rows, N_columnsT_unwrapped
 

Public Member Functions

 TinyMatrix ()
 
 TinyMatrix (const T_matrix &)
 
template<typename T_numtype2 >
 TinyMatrix (const TinyMatrix< T_numtype2, N_rows, N_columns > &x)
 
 TinyMatrix (T_numtype initValue)
 
iterator begin ()
 
const_iterator begin () const
 
T_iterator beginFast () const
 
const T_numtype *restrict data () const
 
T_numtype *restrict data ()
 
const T_numtype *restrict dataFirst () const
 
T_numtype *restrict dataFirst ()
 
iterator end ()
 
const_iterator end () const
 
bool isInRange (const T_index &index) const
 
bool isInRange (int i0, int i1) const
 
bool assertInRange (const T_index &BZ_DEBUG_PARAM(index)) const
 
bool assertInRange (int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1)) const
 
T_matrixnoConst () const
 
const T_numtype &restrict operator() (unsigned i, unsigned j) const
 
T_numtype &restrict operator() (unsigned i, unsigned j)
 
const T_numtype &restrict operator() (T_index i) const
 
T_numtype &restrict operator() (T_index i)
 
template<int N0, int N1>
_bz_ArrayExpr< ArrayIndexMapping< typename asExpr< T_matrix >::T_expr, N0, N1 > > operator() (IndexPlaceholder< N0 >, IndexPlaceholder< N1 >) const
 
const T_numtypefastRead (diffType i) const
 Fastread must return reference so the iterator can turn it into an iterator for the contained in case we have a multicomponent.
 
bool isVectorAligned (diffType offset) const
 Since data_ is simd aligned by construction, we just have to check the offest.
 
ListInitializationSwitch< T_matrix, T_numtype * > operator= (T_numtype x)
 
T_matrixinitialize (T_numtype x)
 
T_numtype *restrict getInitializationIterator ()
 
template<typename T_expr >
T_matrixoperator= (const ETBase< T_expr > &)
 
template<typename T >
T_matrixoperator+= (const T &)
 
template<typename T >
T_matrixoperator-= (const T &)
 
template<typename T >
T_matrixoperator*= (const T &)
 
template<typename T >
T_matrixoperator/= (const T &)
 
template<typename T >
T_matrixoperator%= (const T &)
 
template<typename T >
T_matrixoperator^= (const T &)
 
template<typename T >
T_matrixoperator&= (const T &)
 
template<typename T >
T_matrixoperator|= (const T &)
 
template<typename T >
T_matrixoperator>>= (const T &)
 
template<typename T >
T_matrixoperator<<= (const T &)
 
template<typename T_expr , typename T_update >
_bz_forceinline void _tm_evaluate (const T_expr &expr, T_update)
 This function selects evaluation path by calling select_evaluation with a bool argument which is false if the expression only contains TinyMatrix operands.
 
- Public Member Functions inherited from blitz::ETBase< TinyMatrix< P_numtype, N_rows, N_columns > >
 ETBase ()
 
 ETBase (const ETBase< TinyMatrix< P_numtype, N_rows, N_columns > > &)
 
TinyMatrix< P_numtype, N_rows, N_columns > & unwrap ()
 
const TinyMatrix< P_numtype, N_rows, N_columns > & unwrap () const
 
ETBase< TinyMatrix< P_numtype, N_rows, N_columns > > & wrap ()
 
const ETBase< TinyMatrix< P_numtype, N_rows, N_columns > > & wrap () const
 

Static Public Member Functions

static TinyVector< int, 2 > base ()
 
static int base (int rank)
 
static int cols ()
 
static int columns ()
 
static int dimensions ()
 
static RectDomain< 2 > domain ()
 
static int extent (int rank)
 
static const TinyVector< int, 2 > extent ()
 
static bool isMajorRank (int rank)
 
static bool isMinorRank (int rank)
 
static bool isRankStoredAscending (int rank)
 
static int lbound (int rank)
 
static TinyVector< int, 2 > lbound ()
 
static int length (int rank)
 
static TinyVector< int, 2 > length ()
 
static sizeType numElements ()
 
static int ordering (int rank)
 
static TinyVector< int, 2 > ordering ()
 
static int rank ()
 
static int rows ()
 
static TinyVector< int, 2 > shape ()
 
static sizeType size ()
 
static TinyVector< diffType, 2 > stride ()
 
static diffType stride (int rank)
 
static int ubound (int rank)
 
static TinyVector< int, 2 > ubound ()
 
static int zeroOffset ()
 
static bool canCollapse (int outerRank, int innerRank)
 

Static Public Attributes

static const int rank_ = 2
 

Private Member Functions

template<typename T_expr , typename T_update >
void _tm_evaluate (const T_expr &expr, T_update)
 

Member Typedef Documentation

◆ const_iterator

template<typename P_numtype , int N_rows, int N_columns>
typedef const T_numtype* blitz::TinyMatrix< P_numtype, N_rows, N_columns >::const_iterator

◆ iterator

template<typename P_numtype , int N_rows, int N_columns>
typedef T_numtype* blitz::TinyMatrix< P_numtype, N_rows, N_columns >::iterator

◆ T_index

template<typename P_numtype , int N_rows, int N_columns>
typedef TinyVector<int, 2> blitz::TinyMatrix< P_numtype, N_rows, N_columns >::T_index

◆ T_iterator

◆ T_matrix

◆ T_numtype

template<typename P_numtype , int N_rows, int N_columns>
typedef P_numtype blitz::TinyMatrix< P_numtype, N_rows, N_columns >::T_numtype

◆ T_range_result

Constructor & Destructor Documentation

◆ TinyMatrix() [1/4]

template<typename P_numtype , int N_rows, int N_columns>
blitz::TinyMatrix< P_numtype, N_rows, N_columns >::TinyMatrix ( )
inline

◆ TinyMatrix() [2/4]

template<typename P_numtype , int N_rows, int N_columns>
blitz::TinyMatrix< P_numtype, N_rows, N_columns >::TinyMatrix ( const T_matrix & )
inline

◆ TinyMatrix() [3/4]

template<typename P_numtype , int N_rows, int N_columns>
template<typename T_numtype2 >
blitz::TinyMatrix< P_numtype, N_rows, N_columns >::TinyMatrix ( const TinyMatrix< T_numtype2, N_rows, N_columns > & x)
inline

◆ TinyMatrix() [4/4]

template<typename P_numtype , int N_rows, int N_columns>
blitz::TinyMatrix< P_numtype, N_rows, N_columns >::TinyMatrix ( T_numtype initValue)
inline

Member Function Documentation

◆ _tm_evaluate() [1/2]

template<typename P_numtype , int N_rows, int N_columns>
void blitz::TinyMatrix< P_numtype, N_rows, N_columns >::_tm_evaluate ( const T_expr & expr,
T_update  )
private

◆ _tm_evaluate() [2/2]

template<typename P_numtype , int N_rows, int N_columns>
_bz_forceinline void blitz::TinyMatrix< P_numtype, N_rows, N_columns >::_tm_evaluate ( const T_expr & expr,
T_update  )

This function selects evaluation path by calling select_evaluation with a bool argument which is false if the expression only contains TinyMatrix operands.

References blitz::MemoryBlockReference< P_type >::MemoryBlockReference(), and blitz::_tm_evaluator< unroll, N_rows, N_columns >::select_evaluation().

◆ assertInRange() [1/2]

◆ assertInRange() [2/2]

◆ base() [1/2]

◆ base() [2/2]

template<typename P_numtype , int N_rows, int N_columns>
static int blitz::TinyMatrix< P_numtype, N_rows, N_columns >::base ( int rank)
inlinestatic

◆ begin() [1/2]

template<typename P_numtype , int N_rows, int N_columns>
iterator blitz::TinyMatrix< P_numtype, N_rows, N_columns >::begin ( )
inline

◆ begin() [2/2]

template<typename P_numtype , int N_rows, int N_columns>
const_iterator blitz::TinyMatrix< P_numtype, N_rows, N_columns >::begin ( ) const
inline

◆ beginFast()

template<typename P_numtype , int N_rows, int N_columns>
T_iterator blitz::TinyMatrix< P_numtype, N_rows, N_columns >::beginFast ( ) const
inline

◆ canCollapse()

◆ cols()

template<typename P_numtype , int N_rows, int N_columns>
static int blitz::TinyMatrix< P_numtype, N_rows, N_columns >::cols ( )
inlinestatic

◆ columns()

template<typename P_numtype , int N_rows, int N_columns>
static int blitz::TinyMatrix< P_numtype, N_rows, N_columns >::columns ( )
inlinestatic

◆ data() [1/2]

template<typename P_numtype , int N_rows, int N_columns>
T_numtype *restrict blitz::TinyMatrix< P_numtype, N_rows, N_columns >::data ( )
inline

◆ data() [2/2]

template<typename P_numtype , int N_rows, int N_columns>
const T_numtype *restrict blitz::TinyMatrix< P_numtype, N_rows, N_columns >::data ( ) const
inline

◆ dataFirst() [1/2]

template<typename P_numtype , int N_rows, int N_columns>
T_numtype *restrict blitz::TinyMatrix< P_numtype, N_rows, N_columns >::dataFirst ( )
inline

◆ dataFirst() [2/2]

◆ dimensions()

template<typename P_numtype , int N_rows, int N_columns>
static int blitz::TinyMatrix< P_numtype, N_rows, N_columns >::dimensions ( )
inlinestatic

◆ domain()

template<typename P_numtype , int N_rows, int N_columns>
static RectDomain< 2 > blitz::TinyMatrix< P_numtype, N_rows, N_columns >::domain ( )
static

◆ end() [1/2]

◆ end() [2/2]

◆ extent() [1/2]

◆ extent() [2/2]

template<typename P_numtype , int N_rows, int N_columns>
static int blitz::TinyMatrix< P_numtype, N_rows, N_columns >::extent ( int rank)
inlinestatic

◆ fastRead()

template<typename P_numtype , int N_rows, int N_columns>
const T_numtype & blitz::TinyMatrix< P_numtype, N_rows, N_columns >::fastRead ( diffType i) const
inline

Fastread must return reference so the iterator can turn it into an iterator for the contained in case we have a multicomponent.

◆ getInitializationIterator()

template<typename P_numtype , int N_rows, int N_columns>
T_numtype *restrict blitz::TinyMatrix< P_numtype, N_rows, N_columns >::getInitializationIterator ( )
inline

◆ initialize()

template<typename P_numtype , int N_rows, int N_columns>
T_matrix & blitz::TinyMatrix< P_numtype, N_rows, N_columns >::initialize ( T_numtype x)

◆ isInRange() [1/2]

◆ isInRange() [2/2]

◆ isMajorRank()

template<typename P_numtype , int N_rows, int N_columns>
static bool blitz::TinyMatrix< P_numtype, N_rows, N_columns >::isMajorRank ( int rank)
inlinestatic

◆ isMinorRank()

template<typename P_numtype , int N_rows, int N_columns>
static bool blitz::TinyMatrix< P_numtype, N_rows, N_columns >::isMinorRank ( int rank)
inlinestatic

◆ isRankStoredAscending()

template<typename P_numtype , int N_rows, int N_columns>
static bool blitz::TinyMatrix< P_numtype, N_rows, N_columns >::isRankStoredAscending ( int rank)
inlinestatic

◆ isVectorAligned()

template<typename P_numtype , int N_rows, int N_columns>
bool blitz::TinyMatrix< P_numtype, N_rows, N_columns >::isVectorAligned ( diffType offset) const
inline

Since data_ is simd aligned by construction, we just have to check the offest.

◆ lbound() [1/2]

template<typename P_numtype , int N_rows, int N_columns>
static TinyVector< int, 2 > blitz::TinyMatrix< P_numtype, N_rows, N_columns >::lbound ( )
inlinestatic

◆ lbound() [2/2]

template<typename P_numtype , int N_rows, int N_columns>
static int blitz::TinyMatrix< P_numtype, N_rows, N_columns >::lbound ( int rank)
inlinestatic

◆ length() [1/2]

◆ length() [2/2]

template<typename P_numtype , int N_rows, int N_columns>
static int blitz::TinyMatrix< P_numtype, N_rows, N_columns >::length ( int rank)
inlinestatic

◆ noConst()

template<typename P_numtype , int N_rows, int N_columns>
T_matrix & blitz::TinyMatrix< P_numtype, N_rows, N_columns >::noConst ( ) const
inline

◆ numElements()

template<typename P_numtype , int N_rows, int N_columns>
static sizeType blitz::TinyMatrix< P_numtype, N_rows, N_columns >::numElements ( )
inlinestatic

◆ operator%=()

template<typename P_numtype , int N_rows, int N_columns>
template<typename T >
T_matrix & blitz::TinyMatrix< P_numtype, N_rows, N_columns >::operator%= ( const T & )

◆ operator&=()

template<typename P_numtype , int N_rows, int N_columns>
template<typename T >
T_matrix & blitz::TinyMatrix< P_numtype, N_rows, N_columns >::operator&= ( const T & )

◆ operator()() [1/5]

template<typename P_numtype , int N_rows, int N_columns>
template<int N0, int N1>
_bz_ArrayExpr< ArrayIndexMapping< typename asExpr< T_matrix >::T_expr, N0, N1 > > blitz::TinyMatrix< P_numtype, N_rows, N_columns >::operator() ( IndexPlaceholder< N0 > ,
IndexPlaceholder< N1 >  ) const
inline

◆ operator()() [2/5]

◆ operator()() [3/5]

◆ operator()() [4/5]

◆ operator()() [5/5]

◆ operator*=()

template<typename P_numtype , int N_rows, int N_columns>
template<typename T >
T_matrix & blitz::TinyMatrix< P_numtype, N_rows, N_columns >::operator*= ( const T & )

◆ operator+=()

template<typename P_numtype , int N_rows, int N_columns>
template<typename T >
T_matrix & blitz::TinyMatrix< P_numtype, N_rows, N_columns >::operator+= ( const T & )

◆ operator-=()

template<typename P_numtype , int N_rows, int N_columns>
template<typename T >
T_matrix & blitz::TinyMatrix< P_numtype, N_rows, N_columns >::operator-= ( const T & )

◆ operator/=()

template<typename P_numtype , int N_rows, int N_columns>
template<typename T >
T_matrix & blitz::TinyMatrix< P_numtype, N_rows, N_columns >::operator/= ( const T & )

◆ operator<<=()

template<typename P_numtype , int N_rows, int N_columns>
template<typename T >
T_matrix & blitz::TinyMatrix< P_numtype, N_rows, N_columns >::operator<<= ( const T & )

◆ operator=() [1/2]

template<typename P_numtype , int N_rows, int N_columns>
template<typename T_expr >
T_matrix & blitz::TinyMatrix< P_numtype, N_rows, N_columns >::operator= ( const ETBase< T_expr > & )

◆ operator=() [2/2]

template<typename P_numtype , int N_rows, int N_columns>
ListInitializationSwitch< T_matrix, T_numtype * > blitz::TinyMatrix< P_numtype, N_rows, N_columns >::operator= ( T_numtype x)
inline

◆ operator>>=()

template<typename P_numtype , int N_rows, int N_columns>
template<typename T >
T_matrix & blitz::TinyMatrix< P_numtype, N_rows, N_columns >::operator>>= ( const T & )

◆ operator^=()

template<typename P_numtype , int N_rows, int N_columns>
template<typename T >
T_matrix & blitz::TinyMatrix< P_numtype, N_rows, N_columns >::operator^= ( const T & )

◆ operator|=()

template<typename P_numtype , int N_rows, int N_columns>
template<typename T >
T_matrix & blitz::TinyMatrix< P_numtype, N_rows, N_columns >::operator|= ( const T & )

◆ ordering() [1/2]

template<typename P_numtype , int N_rows, int N_columns>
static TinyVector< int, 2 > blitz::TinyMatrix< P_numtype, N_rows, N_columns >::ordering ( )
inlinestatic

◆ ordering() [2/2]

template<typename P_numtype , int N_rows, int N_columns>
static int blitz::TinyMatrix< P_numtype, N_rows, N_columns >::ordering ( int rank)
inlinestatic

◆ rank()

◆ rows()

template<typename P_numtype , int N_rows, int N_columns>
static int blitz::TinyMatrix< P_numtype, N_rows, N_columns >::rows ( )
inlinestatic

◆ shape()

◆ size()

◆ stride() [1/2]

◆ stride() [2/2]

◆ ubound() [1/2]

◆ ubound() [2/2]

◆ zeroOffset()

template<typename P_numtype , int N_rows, int N_columns>
static int blitz::TinyMatrix< P_numtype, N_rows, N_columns >::zeroOffset ( )
inlinestatic

Member Data Documentation

◆ rank_


The documentation for this class was generated from the following files: