cubebase.h

Go to the documentation of this file.

// Copyright (C) 1997-2010 by Pawel Pilarczyk.
//
// This file is part of the Homology Library.  This library 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 of the License, or (at your option) any later version.
//
// This library 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 software; see the file "license.txt".  If not, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// Started in January 2002. Last revision: May 25, 2010.


#ifndef _CHOMP_CUBES_CUBEBASE_H_
#define _CHOMP_CUBES_CUBEBASE_H_

#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
#include "chomp/cubes/pointset.h"
#include "chomp/struct/bitfield.h"
#include "chomp/struct/integer.h"
#include "chomp/struct/hashsets.h"
#include "chomp/cubes/pointbas.h"
#include "chomp/cubes/cubemain.h"

#include <iostream>
#include <fstream>
#include <cstdlib>
#include <cstring>

namespace chomp {
namespace homology {


// a friend class template
template <class coordtype>
class tCellBase;


// --------------------------------------------------
// -------------- Cube with PointBase ---------------
// --------------------------------------------------

template <class coordtype>
class tCubeBase
{
public:
        typedef coordtype CoordType;

        typedef tCellBase<coordtype> CellType;

        static const int MaxDim = MaxBasDim;

        typedef tPointBase<coordtype> PointBase;

        tCubeBase ();
        
        tCubeBase (const coordtype *c, int dim);

        tCubeBase (int_t number, int dim);

        tCubeBase (const tCubeBase<coordtype> &c);

        tCubeBase<coordtype> &operator =
                (const tCubeBase<coordtype> &c);

        int dim () const;

//      template <class intType>
//      intType *coord (intType *c) const;
        coordtype *coord (coordtype *c) const;

        int_t hashkey1 () const;

        int_t hashkey2 () const;

        static const char *name ();

        static const char *pluralname ();

        // --- friends: ---

        friend inline int operator == (const tCubeBase<coordtype> &c1,
                const tCubeBase<coordtype> &c2)
        {
                return c1. n == c2. n;
        } /* operator == */

        // friend class: cubical cell
        friend class tCellBase<coordtype>;

private:
        int_t num () const;

        int_t n;

}; /* class tCubeBase */

// --------------------------------------------------

template <class coordtype>
inline int_t tCubeBase<coordtype>::num () const
{
        return (n & NumMask);
} /* tCubeBase::num */

// --------------------------------------------------

template <class coordtype>
inline tCubeBase<coordtype>::tCubeBase ()
: n (0)
{
        return;
} /* tCubeBase::tCubeBase */

template <class coordtype>
inline tCubeBase<coordtype>::tCubeBase (const coordtype *c,
        int dim)
{
        if (dim <= 0)
                throw "Non-positive dimension of a cube.";
        if (dim >= MaxDim)
                throw "Too high space dimension.";
        n = PointBase::number (c, dim);
        if (n < 0)
                throw "Negative number of a cube.";
        n |= (static_cast<int_t> (dim) << NumBits);
        return;
} /* tCubeBase::tCubeBase */

template <class coordtype>
inline tCubeBase<coordtype>::tCubeBase (int_t number, int dim)
{
        n = number | (static_cast<int_t> (dim) << NumBits);
        return;
} /* tCubeBase::tCubeBase */

template <class coordtype>
inline tCubeBase<coordtype>::tCubeBase (const tCubeBase<coordtype> &c)
{
        n = c. n;
        return;
} /* tCubeBase::tCubeBase */

template <class coordtype>
inline tCubeBase<coordtype> &tCubeBase<coordtype>::operator =
        (const tCubeBase<coordtype> &c)
{
        n = c. n;
        return *this;
} /* tCubeBase::operator = */

template <class coordtype>
inline int tCubeBase<coordtype>::dim () const
{
        return static_cast<int> (n >> NumBits);
} /* tCubeBase::dim */

//template <class coordtype>
//template <class intType>
//inline intType *tCubeBase<coordtype>::coord (intType *c) const
//{
//      int d = dim ();
//      const coordtype *tab = PointBase::coord (num (), d);
//      for (int i = 0; i < d; ++ i)
//              c [i] = static_cast<const intType> (tab [i]);
//      return c;
//} /* tCubeBase::coord */

template <class coordtype>
inline coordtype *tCubeBase<coordtype>::coord (coordtype *c) const
{
        int d = dim ();
        const coordtype *tab = PointBase::coord (num (), d);
        for (int i = 0; i < d; ++ i)
                c [i] = tab [i];
        return c;
} /* tCubeBase::coord */

template <class coordtype>
inline int_t tCubeBase<coordtype>::hashkey1 () const
{
        return static_cast<int_t>
                (((n ^ 0x55555555u) << 17) ^ ((n ^ 0xAA00AA00u) << 7) ^
                ((n ^ 0x00AA00AAu) >> 7));
} /* tCubeBase::hashkey1 */

template <class coordtype>
inline int_t tCubeBase<coordtype>::hashkey2 () const
{
        return static_cast<int_t>
                (((n ^ 0xAAAAAAAAu) << 18) ^ ((n ^ 0x55005500u) >> 8) ^
                ((n ^ 0x00550055u) << 10));
} /* tCubeBase::hashkey2 */

template <class coordtype>
inline const char *tCubeBase<coordtype>::name ()
{
        return "cube";
} /* tCubeBase::name */

template <class coordtype>
inline const char *tCubeBase<coordtype>::pluralname ()
{
        return "cubes";
} /* tCubeBase::pluralname */

// --------------------------------------------------

template <class coordtype>
inline int operator != (const tCubeBase<coordtype> &c1,
        const tCubeBase<coordtype> &c2)
{
        return !(c1 == c2);
} /* operator != */

// --------------------------------------------------

template <class coordtype>
inline tCubeBase<coordtype> operator * (const tCubeBase<coordtype> &c1,
        const tCubeBase<coordtype> &c2)
{
        int dim1 = c1. dim (), dim2 = c2. dim ();
        if (dim1 + dim2 >= tCubeBase<coordtype>::MaxDim)
                throw "Dimension too high to concatenate coordinates.";
        coordtype coord [tCubeBase<coordtype>::MaxDim];
        c1. coord (coord);
        c2. coord (coord + dim1);
        return tCubeBase<coordtype> (coord, dim1 + dim2);
} /* operator * */

// --------------------------------------------------

template <class coordtype>
inline std::ostream &operator << (std::ostream &out,
        const tCubeBase<coordtype> &c)
{
        return WriteCube (out, c);
} /* operator << */

template <class coordtype>
inline std::istream &operator >> (std::istream &in, tCubeBase<coordtype> &c)
{
        return ReadCube (in, c);
} /* operator >> */

template <class coordtype>
inline std::istream &operator >> (std::istream &in,
        hashedset<tCubeBase<coordtype> > &s)
{
        return ReadCubes (in, s);
} /* operator >> */

template <class coordtype>
inline std::istream &operator >> (std::istream &in,
        mvmap<tCubeBase<coordtype>,tCubeBase<coordtype> > &m)
{
        return ReadCubicalMap (in, m);
} /* operator >> */


} // namespace homology
} // namespace chomp

#endif // _CHOMP_CUBES_CUBEBASE_H_