Array3D.h

Go to the documentation of this file.

//            QMcBeaver
//
//         Constructed by 
//
//     Michael Todd Feldmann 
//              and 
//   David Randall "Chip" Kent IV
//
// Copyright 2000.  All rights reserved.
//
// drkent@users.sourceforge.net mtfeldmann@users.sourceforge.net

/**************************************************************************
This SOFTWARE has been authored or contributed to by an employee or 
employees of the University of California, operator of the Los Alamos 
National Laboratory under Contract No. W-7405-ENG-36 with the U.S. 
Department of Energy.  The U.S. Government has rights to use, reproduce, 
and distribute this SOFTWARE.  Neither the Government nor the University 
makes any warranty, express or implied, or assumes any liability or 
responsibility for the use of this SOFTWARE.  If SOFTWARE is modified 
to produce derivative works, such modified SOFTWARE should be clearly 
marked, so as not to confuse it with the version available from LANL.   

Additionally, this program is free software; you can distribute it and/or 
modify it under the terms of the GNU General Public License. Accordingly, 
this program is  distributed in the hope that it will be useful, but WITHOUT 
ANY WARRANTY;  without even the implied warranty of MERCHANTABILITY or 
FITNESS FOR A  PARTICULAR PURPOSE.  See the GNU General Public License 
for more details. 
**************************************************************************/


#ifndef Array3D_H
#define Array3D_H

#include "Array2D.h"

template <class T> class Array3D
{
 private:
  int n_1;

  int n_2;

  int n_3;

  T*** pArray;

public:

  int dim1(){return n_1;}

  int dim2(){return n_2;}

  int dim3(){return n_3;}

  int size(){return n_1*n_2*n_3;}

  T*** array(){return pArray;}

  void allocate(int i, int j, int k)
    {
      if( n_1 != i || n_2 != j || n_3 != k )
        {
          deallocate();

          n_1 = i;
          n_2 = j;
          n_3 = k;

          if(n_1 >= 1 && n_2 >= 1 && n_3 >= 1)
            {
              pArray = new T**[n_1];
              for(int ii=0; ii< n_1; ii++)
                {
                  pArray[ii] = new T*[n_2];
                  for(int jj=0; jj<n_2; jj++) pArray[ii][jj] = new T[n_3];
                }
            }
          else 
            {
              pArray = 0;
            }
        }
    }

  void deallocate()
    {
     for(int i=0; i<n_1; i++)
          {
           for(int j=0; j<n_2; j++) delete [] pArray[i][j];
           delete [] pArray[i];
     }
     delete [] pArray;
     pArray = 0;

     n_1 = 0;
     n_2 = 0;
     n_3 = 0;
    }

  void operator=(const Array3D & rhs)
    {
     if(n_1 != rhs.n_1 || n_2 != rhs.n_2 || n_3 != rhs.n_3)
       allocate(rhs.n_1,rhs.n_2,rhs.n_3);

      for(int i=0; i<n_1;i++)
        for(int j=0; j<n_2;j++)
          for(int k=0; k<n_3;k++)
            pArray[i][j][k] = rhs.pArray[i][j][k];
    }

  void operator=(const T C)
    {
      for(int i=0; i<n_1;i++)
        for(int j=0; j<n_2;j++)
          for(int k=0; k<n_3;k++)
            pArray[i][j][k] = C;
    }

  Array3D(){pArray = 0; n_1 = 0; n_2 = 0; n_3 = 0;}

  Array3D(int i, int j, int k)
    {pArray = 0; n_1 = 0; n_2 = 0; n_3 = 0; allocate(i,j, k);}

  Array3D( const Array3D<T> & rhs)
    {
      n_1 = 0;
      n_2 = 0;
      n_3 = 0;
      pArray = 0;
      allocate(rhs.n_1, rhs.n_2, rhs.n_3);

      for(int i=0; i<n_1; i++)
        for(int j=0; j<n_2; j++)
          for(int k=0; k<n_3; k++)
            pArray[i][j][k] = rhs.pArray[i][j][k];
    }

  ~Array3D(){deallocate();}

  T& operator()(int i,int j, int k){return pArray[i][j][k];}

  friend ostream& operator<<(ostream & strm, const Array3D<T> & rhs)
    {
      for (int i=0; i<rhs.n_1; i++)
        {
          for (int j=0; j<rhs.n_2; j++)
            {
              for (int k=0; k<rhs.n_3; k++)
                {
                  strm << rhs.pArray[i][j][k] << "\t";
                }
              strm << endl;
            }
          strm << endl << endl;
        }
      return strm;
    }

};

#endif

---