Array3DShape.hpp

Go to the documentation of this file.

//  This file is part of ff3d - http://www.freefem.org/ff3d
//  Copyright (C) 2001, 2002, 2003 Stéphane Del Pino

//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2, or (at your option)
//  any later version.

//  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.

//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

//  $Id: Array3DShape.hpp,v 1.5 2008/01/16 20:37:42 delpinux Exp $


#ifndef _ARRAY_3D_SHAPE_
#define _ARRAY_3D_SHAPE_

#include <TinyVector.hpp>
#include <StreamCenter.hpp>

class Array3DShape
{
private:
  TinyVector<3,size_t> __shape;

public:  
  friend std::ostream& operator << (std::ostream& os, const Array3DShape& a)
  {
    os << a.__shape;
    return os;
  }

  bool operator==(const Array3DShape& s) const
  {
    return (__shape==s.__shape);
  }

  inline size_t operator()(const size_t& i,
                           const size_t& j,
                           const size_t& k) const
  {
    return (i*__shape[1]*__shape[2] + j*__shape[2] + k);
  }

  inline size_t operator()(const TinyVector<3,size_t>& index) const
  {
    return (*this)(index[0],index[1],index[2]);
  }


  inline const size_t& nx() const
  {
    return __shape[0];
  }

  inline const size_t& ny() const
  {
    return __shape[1];
  }

  inline const size_t& nz() const
  {
    return __shape[2];
  }

  inline const size_t& operator[](const size_t& i) const
  {
    ASSERT(i<3);
    return __shape[i];
  }

  inline size_t size() const
  {
    return __shape[0]*__shape[1]*__shape[2];
  }

  inline Array3DShape operator-(size_t i) const
  {
    ASSERT ((i<__shape[0])&&(i<__shape[1])&&(i<__shape[2]));
    return Array3DShape(__shape[0]-i, __shape[1]-i, __shape[2]-i);
  }

  inline Array3DShape& operator=(const Array3DShape& s)
  {
    __shape = s.__shape;
    return *this;
  }

  Array3DShape(const size_t& i,
               const size_t& j,
               const size_t& k)
  {
    __shape[0]=i;
    __shape[1]=j;
    __shape[2]=k;
  }

  Array3DShape(const TinyVector<3,size_t>& shape)
    : __shape(shape)
  {
    ;
  }

  Array3DShape(const Array3DShape& s)
    : __shape(s.__shape)
  {
    ;
  }

  Array3DShape()
  {
    ;
  }

  ~Array3DShape()
  {
    ;
  }
};

#endif // _STUCTURED_3D_MESH_SHAPE_HPP_

---