cube.hh

#ifndef DUNE_SPGRID_CUBE_HH
#define DUNE_SPGRID_CUBE_HH
 
#include <dune/common/fvector.hh>
 
#include <dune/common/iostream.hh>
 
namespace Dune
{
 
  // SPCube
  // ------
 
  template< class ct, int dim >
  class SPCube
  {
    typedef SPCube< ct, dim > This;
 
  public:
    typedef ct ctype;
 
    static const int dimension = dim;
 
    typedef FieldVector< ctype, dimension > GlobalVector;
 
    SPCube ();
 
    SPCube ( const GlobalVector &a, const GlobalVector &b );
 
    const GlobalVector &origin () const;
 
    const GlobalVector &width () const;
 
    bool contains ( const GlobalVector &x ) const;
 
    static This unitCube ();
 
  private:
    GlobalVector origin_, width_;
  };
 
 
 
  // Implementation of SPCube
  // ------------------------
 
  template< class ct, int dim >
  inline SPCube< ct, dim >::SPCube ()
  {
    for( int i = 0; i < dimension; ++i )
      origin_[ i ] = width_[ i ] = 0;
  }
 
 
  template< class ct, int dim >
  inline SPCube< ct, dim >
    ::SPCube ( const GlobalVector &a, const GlobalVector &b )
  {
    for( int i = 0; i < dimension; ++i )
    {
      origin_[ i ] = std::min( a[ i ], b[ i ] );
      width_[ i ] = std::max( a[ i ], b[ i ] ) - origin_[ i ];
    }
  }
 
 
  template< class ct, int dim >
  inline const typename SPCube< ct, dim >::GlobalVector &
  SPCube< ct, dim >::origin () const
  {
    return origin_;
  }
 
 
  template< class ct, int dim >
  inline const typename SPCube< ct, dim >::GlobalVector &
  SPCube< ct, dim >::width () const
  {
    return width_;
  }
 
 
  template< class ct, int dim >
  inline bool SPCube< ct, dim >::contains ( const GlobalVector &x ) const
  {
    bool contains = true;
    for( int i = 0; i < dimension; ++i )
    {
      const ctype y = x[ i ] - origin()[ i ];
      contains &= ((y >= 0) && (y <= width()[ i ]));
    }
    return contains;
  }
 
 
  template< class ct, int dim >
  inline typename SPCube< ct, dim >::This
  SPCube< ct, dim >::unitCube ()
  {
    GlobalVector a, b;
    for( int i = 0; i < dimension; ++i )
    {
      a = ctype( 0 );
      b = ctype( 1 );
    }
    return This( a, b );
  }
 
 
 
  // Auxilliary Functions for SPCube
  // -------------------------------
 
  template< class char_type, class traits, class ct, int dim >
  inline std::basic_ostream< char_type, traits > &
  operator<< ( std::basic_ostream< char_type, traits > &out,
               const SPCube< ct, dim > &cube )
  {
    typedef SPCube< ct, dim > Cube;
    typename Cube::GlobalVector a = cube.origin();
    typename Cube::GlobalVector b = a + cube.width();
    for( int i = 0; i < Cube::dimension; ++i )
      out << (i > 0 ? "x[" : "[") << a[ i ] << "," << b[ i ] << "]";
    return out;
  }
 
 
  template< class char_type, class traits, class ct, int dim >
  inline std::basic_istream< char_type, traits > &
  operator>> ( std::basic_istream< char_type, traits > &in,
               SPCube< ct, dim > &cube )
  {
    typedef SPCube< ct, dim > Cube;
    typename Cube::GlobalVector a;
    typename Cube::GlobalVector b;
    for( int i = 0; i < Cube::dimension; ++i )
    {
      if( i > 0 )
        in >> match( 'x' );
      in >> match( '[' ) >> a[ i ] >> match( ',' ) >> b[ i ] >> match( ']' );
    }
    if( !in.fail() )
      cube = Cube( a, b );
    return in;
  }
 
} // namespace Dune
 
#endif // #ifndef DUNE_SPGRID_CUBE_HH