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

SPUC::Array1D< T > Class Template Reference

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

#include <array1d.h>

Collaboration diagram for SPUC::Array1D< T >:

Collaboration graph
[legend]
List of all members.

Public Types

typedef T value_type

Public Member Functions

 Array1D ()
 Array1D (int n)
 Array1D (int n, T *a)
 Array1D (int n, const T &a)
 Array1D (const Array1D &A)
Array1D & operator= (const T &a)
Array1D & operator= (const Array1D &A)
Array1D & ref (const Array1D &A)
Array1D copy () const
Array1D & inject (const Array1D &A)
T & operator[] (int i)
const T & operator[] (int i) const
int dim1 () const
int dim () const
int ref_count () const
 ~Array1D ()
Array1D< T > mid (int s, int nr) const
void replace_mid (int s, const Array1D< T > &v) const
int length () const
Array1D< T > & set_size (int M, bool f)
Array1D< T > & newsize (int M, bool f)
Array1D< T > & newsize (int M)
Array1D< T > & set_size (int M)

Detailed Description

template<class T>
class SPUC::Array1D< T >

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

Tempplated one-dimensional, numerical array which looks like a conventional C array. Elements are accessed via the familiar A[i] 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] 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::Array1D< T >::value_type
 

Constructor & Destructor Documentation

template<class T>
SPUC::Array1D< T >::Array1D (   ) 
 

Null constructor. Creates a 0-length (NULL) array. (Reference count is also zero.)

template<class T>
SPUC::Array1D< T >::Array1D (  int  n  )  [explicit]
 

Create a new array (vector) of length n, WIHOUT initializing array elements. To create an initialized array of constants, see Array1D(n,value).

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

Parameters:
n the dimension (length) of the new matrix.

template<class T>
SPUC::Array1D< T >::Array1D (  int  n,
T *  a
) 
 

Create a new n-length array, as a view of an existing one-dimensional C array. (Note that the storage for this pre-existing array will never be destroyed by the Aray1DRef class.)

Parameters:
n the dimension (length) of the new matrix.
a the one dimensional C array to use as data storage for the array.

template<class T>
SPUC::Array1D< T >::Array1D (  int  n,
const T &  val
) 
 

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

Parameters:
n the dimension (length) of the new matrix.
val the constant value to set all elements of the new array to.

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

template<class T>
SPUC::Array1D< T >::~Array1D (   ) 
 

Member Function Documentation

template<class T>
Array1D< T > SPUC::Array1D< T >::copy (   )  const
 

Create a new of existing matrix. Used in B = A.copy() or in the construction of B, e.g. Array1D 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::Array1D< T >::dim (   )  const [inline]
 

Returns:
the dimension (number of elements) of the array. This is equivalent to dim1() and dim1().

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

Returns:
the dimension (number of elements) of the array. This is equivalent to dim() and dim1().

template<class T>
Array1D< T > & SPUC::Array1D< T >::inject (  const Array1D< 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 

	Array1D A(n);
	Array1D C(n);
	Array1D 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 which 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> 
        

        

          int SPUC::Array1D< T >::length           
          ( 
                    
           ) 
           const [inline]
        

      

    		
  





  

    
       
    
    



    

  







  

    
      

        

          
template<class T> 
        

        

          Array1D< T > SPUC::Array1D< T >::mid           
          ( 
          int 
           s, 
        

        

          
          
          int 
           nr
        

        

          
          ) 
           const
        

      

    		
  





  

    
       
    
    



    

  







  

    
      

        

          
template<class T> 
        

        

          Array1D<T>& SPUC::Array1D< T >::newsize           
          ( 
          int 
           M          
           ) 
           [inline]
        

      

    		
  





  

    
       
    
    



    

  







  

    
      

        

          
template<class T> 
        

        

          Array1D<T>& SPUC::Array1D< T >::newsize           
          ( 
          int 
           M, 
        

        

          
          
          bool 
           f
        

        

          
          ) 
           [inline]
        

      

    		
  





  

    
       
    
    



    

  







  

    
      

        

          
template<class T> 
        

        

          Array1D& SPUC::Array1D< T >::operator=           
          ( 
          const Array1D< T > & 
           A          
           ) 
           [inline]
        

      

    		
  





  

    
       
    
    



    

  







  

    
      

        

          
template<class T> 
        

        

          Array1D< T > & SPUC::Array1D< T >::operator=           
          ( 
          const T & 
           a          
           ) 
           [inline]
        

      

    		
  





  

    
       
    
    



Assign all elemnts of A to a constant scalar.    

  







  

    
      

        

          
template<class T> 
        

        

          const T & SPUC::Array1D< T >::operator[]           
          ( 
          int 
           i          
           ) 
           const [inline]
        

      

    		
  





  

    
       
    
    



A[i] indexes the ith element of A. The first element is A[0]. If SPUC_BOUNDS_CHECK is defined, then the index is checked that it fall within the array bounds.    

  







  

    
      

        

          
template<class T> 
        

        

          T & SPUC::Array1D< T >::operator[]           
          ( 
          int 
           i          
           ) 
           [inline]
        

      

    		
  





  

    
       
    
    



A[i] indexes the ith element of A. The first element is A[0]. If SPUC_BOUNDS_CHECK is defined, then the index is checked that it falls within the array bounds.    

  







  

    
      

        

          
template<class T> 
        

        

          Array1D& SPUC::Array1D< T >::ref           
          ( 
          const Array1D< T > & 
           A          
           ) 
           [inline]
        

      

    		
  





  

    
       
    
    



    

  







  

    
      

        

          
template<class T> 
        

        

          int SPUC::Array1D< 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> 
        

        

          void SPUC::Array1D< T >::replace_mid           
          ( 
          int 
           s, 
        

        

          
          
          const Array1D< T > & 
           v
        

        

          
          ) 
           const
        

      

    		
  





  

    
       
    
    






Here is the call graph for this function:




    		
  







  

    
      

        

          
template<class T> 
        

        

          Array1D<T>& SPUC::Array1D< T >::set_size           
          ( 
          int 
           M          
           ) 
           [inline]
        

      

    		
  





  

    
       
    
    



    

  







  

    
      

        

          
template<class T> 
        

        

          Array1D<T>& SPUC::Array1D< T >::set_size           
          ( 
          int 
           M, 
        

        

          
          
          bool 
           f
        

        

          
          ) 
           [inline]
        

      

    		
  





  

    
       
    
    



    

  




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

Generated on Fri Sep 16 11:07:19 2005 for spuc by 

doxygen 1.4.4