Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

SPUC::Array2D< T > Class Template Reference

Templated two-dimensional, numerical array which looks like a conventional C multiarray. More...

#include <array2d.h>

Collaboration diagram for SPUC::Array2D< T >:

Collaboration graph
[legend]
List of all members.

Public Types

typedef T value_type

Public Member Functions

 Array2D ()
 Array2D (int m, int n)
 Array2D (int m, int n, T *a)
 Array2D (int m, int n, const T &a)
 Array2D (const Array2D &A)
Array2Doperator= (const T &a)
Array2Doperator= (const Array2D &A)
Array2Dref (const Array2D &A)
Array2D copy () const
Array2Dinject (const Array2D &A)
T * operator[] (int i)
const T * operator[] (int i) const
int dim1 () const
int dim2 () const
int ref_count () const
 ~Array2D ()
int cols () const
int rows () const
Array2D< T > & newsize (int M, int N)
Array2D< T > & set_size (int M, int N)

Detailed Description

template<class T>
class SPUC::Array2D< T >

Templated two-dimensional, numerical array which looks like a conventional C multiarray.

Tempplated two-dimensional, numerical array which looks like a conventional C multiarray. Storage corresponds to C (row-major) ordering. Elements are accessed via A[i][j] notation.

Array assignment is by reference (i.e. shallow assignment). That is, B=A implies that the A and B point to the same array, so modifications to the elements of A will be reflected in B. If an independent copy is required, then B = A.copy() can be used. Note that this facilitates returning arrays from functions without relying on compiler optimizations to eliminate extensive data copying.

The indexing and layout of this array object makes it compatible with C and C++ algorithms that utilize the familiar C[i][j] notation. This includes numerous textbooks, such as Numercial Recipes, and various public domain codes.

This class employs its own garbage collection via the use of reference counts. That is, whenever an internal array storage no longer has any references to it, it is destoryed.


Member Typedef Documentation

template<class T>
typedef T SPUC::Array2D< T >::value_type
 


Constructor & Destructor Documentation

template<class T>
SPUC::Array2D< T >::Array2D  ) 
 

Create a null (0x0) array.

template<class T>
SPUC::Array2D< T >::Array2D int  m,
int  n
 

Create a new (m x n) array, WIHOUT initializing array elements. To create an initialized array of constants, see Array2D(m,n,value).

This version avoids the O(m*n) initialization overhead and is used just before manual assignment.

Parameters:
m the first (row) dimension of the new matrix.
n the second (column) dimension of the new matrix.

template<class T>
SPUC::Array2D< T >::Array2D int  m,
int  n,
T *  a
 

Create a new (m x n) array, as a view of an existing one-dimensional array stored in C order, i.e. right-most dimension varying fastest. (Often referred to as "row-major" ordering.) Note that the storage for this pre-existing array will never be garbage collected by the Array2D class.

Parameters:
m the first (row) dimension of the new matrix.
n the second (column) dimension of the new matrix.
a the one dimensional C array to use as data storage for the array.

template<class T>
SPUC::Array2D< T >::Array2D int  m,
int  n,
const T &  val
 

Create a new (m x n) array, initializing array elements to constant specified by argument. Most often used to create an array of zeros, as in A(m, n, 0.0).

Parameters:
m the first (row) dimension of the new matrix.
n the second (column) dimension of the new matrix.
val the constant value to set all elements of the new array to.

template<class T>
SPUC::Array2D< T >::Array2D const Array2D< T > &  A  )  [inline]
 

template<class T>
SPUC::Array2D< T >::~Array2D  ) 
 


Member Function Documentation

template<class T>
int SPUC::Array2D< T >::cols  )  const [inline]
 

template<class T>
Array2D< T > SPUC::Array2D< T >::copy  )  const
 

Create a new of existing matrix. Used in B = A.copy() or in the construction of B, e.g. Array2D B(A.copy()), to create a new array that does not share data.

Here is the call graph for this function:

template<class T>
int SPUC::Array2D< T >::dim1  )  const [inline]
 

Returns:
the size of the first dimension of the array, i.e. the number of rows.

template<class T>
int SPUC::Array2D< T >::dim2  )  const [inline]
 

Returns:
the size of the second dimension of the array, i.e. the number of columns.

template<class T>
Array2D< T > & SPUC::Array2D< T >::inject const Array2D< T > &  A  ) 
 

Copy the elements to from one array to another, in place. That is B.inject(A), both A and B must conform (i.e. have identical row and column dimensions).

This differs from B = A.copy() in that references to B before this assignment are also affected. That is, if we have

	Array2D A(m,n);
	Array2D C(m,n);
	Array2D B(C);        // elements of B and C are shared.

 then B.inject(A) affects both and C, while B=A.copy() creates a new array B which shares no data with C or A.

Parameters:
A the array from elements will be copied
Returns:
an instance of the modifed array. That is, in B.inject(A), it returns B. If A and B are not conformat, no modifications to B are made.

Here is the call graph for this function:

template<class T>
Array2D<T>& SPUC::Array2D< T >::newsize int  M,
int  N
[inline]
 

template<class T>
Array2D& SPUC::Array2D< T >::operator= const Array2D< T > &  A  )  [inline]
 

template<class T>
Array2D< T > & SPUC::Array2D< T >::operator= const T &  a  )  [inline]
 

Assign all elemnts of A to a constant scalar.

template<class T>
const T * SPUC::Array2D< T >::operator[] int  i  )  const [inline]
 

template<class T>
T * SPUC::Array2D< T >::operator[] int  i  )  [inline]
 

Used for A[i][j] indexing. The first [] operator returns a conventional pointer which can be dereferenced using the same [] notation.

If TNT_BOUNDS_CHECK macro is define, the left-most index (row index) is checked that it falls within the array bounds (via the assert() macro.) Note that bounds checking can occur in the row dimension, but the not column, since this is just a C pointer.

template<class T>
Array2D& SPUC::Array2D< T >::ref const Array2D< T > &  A  )  [inline]
 

template<class T>
int SPUC::Array2D< T >::ref_count  )  const [inline]
 

Returns:
the number of arrays that share the same storage area as this one. (Must be at least one.)

template<class T>
int SPUC::Array2D< T >::rows  )  const [inline]
 

template<class T>
Array2D<T>& SPUC::Array2D< T >::set_size int  M,
int  N
[inline]
 


The documentation for this class was generated from the following file:
Generated on Fri Sep 16 11:07:21 2005 for spuc by  doxygen 1.4.4