cubefix.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: June 1, 2007.


#ifndef _CHOMP_CUBES_CUBEFIX_H_
#define _CHOMP_CUBES_CUBEFIX_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 <int dimfix, class coordtype>
class tCellFix;


// --------------------------------------------------
// ------------ Cube of fixed dimension -------------
// --------------------------------------------------

template <int dimfix, class coordtype>
class tCubeFix
{
public:
        typedef coordtype CoordType;

        typedef tCellFix<dimfix,coordtype> CellType;

        static const int MaxDim = 512;

        typedef tWrapBase<coordtype> PointBase;

        tCubeFix ();
        
        tCubeFix (const coordtype *c, int dim = 0);

        tCubeFix (int number, int dim);

        tCubeFix (const tCubeFix<dimfix,coordtype> &c);

        tCubeFix<dimfix,coordtype> &operator =
                (const tCubeFix<dimfix,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 ();

        friend int operator == (const tCubeFix<dimfix,coordtype> &c1,
                const tCubeFix<dimfix,coordtype> &c2)
        {
                return thesame (c1. tab, c2. tab, dimfix);
        }

        // friend class: cubical cell
        friend class tCellFix<dimfix, coordtype>;

private:
        coordtype tab [dimfix];

}; /* class tCubeFix */

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

template <int dimfix, class coordtype>
inline tCubeFix<dimfix,coordtype>::tCubeFix ()
{
        return;
} /* tCubeFix::tCubeFix */

template <int dimfix, class coordtype>
inline tCubeFix<dimfix,coordtype>::tCubeFix
        (const coordtype *c, int dim)
{
        if (dim && ((dim != dimfix) || (dim < 0)))
                throw "Wrong dimension of a fixed-dim cube.";
        PointBase::wrapcopy (tab, c, dimfix);
        return;
} /* tCubeFix::tCubeFix */

template <int dimfix, class coordtype>
inline tCubeFix<dimfix,coordtype>::tCubeFix (int, int)
{
        throw "Unable to construct a cube from a number.";
} /* tCubeFix::tCubeFix */

template <int dimfix, class coordtype>
inline tCubeFix<dimfix,coordtype>::tCubeFix
        (const tCubeFix<dimfix,coordtype> &c)
{
        for (int i = 0; i < dimfix; ++ i)
                tab [i] = c. tab [i];
        return;
} /* tCubeFix::tCubeFix */

template <int dimfix, class coordtype>
inline tCubeFix<dimfix,coordtype> &tCubeFix<dimfix,coordtype>::operator =
        (const tCubeFix<dimfix,coordtype> &c)
{
        for (int i = 0; i < dimfix; ++ i)
                tab [i] = c. tab [i];
        return *this;
} /* tCubeFix::operator = */

template <int dimfix, class coordtype>
inline int tCubeFix<dimfix,coordtype>::dim () const
{
        return dimfix;
} /* tCubeFix::dim */

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

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

template <int dimfix, class coordtype>
inline int_t tCubeFix<dimfix,coordtype>::hashkey1 () const
{
        switch (dimfix)
        {
        case 1:
                return static_cast<int_t> (tab [0]) << 12;
        case 2:
                return ((static_cast<int_t> (tab [0])) << 18) +
                        ((static_cast<int_t> (tab [1])) << 6);
        default:
                return ((static_cast<int_t> (tab [0])) << 18) +
                        ((static_cast<int_t> (tab [1])) << 6) +
                        ((static_cast<int_t> (tab [2])) >> 6);
        }
} /* tCubeFix::hashkey1 */

template <int dimfix, class coordtype>
inline int_t tCubeFix<dimfix,coordtype>::hashkey2 () const
{
        switch (dimfix)
        {
        case 1:
                return static_cast<int_t> (tab [0]) << 3;
        case 2:
                return (static_cast<int_t> (tab [0]) >> 1) +
                        (static_cast<int_t> (tab [1]) << 13);
        default:
                return ((static_cast<int_t> (tab [dimfix - 1])) << 20) +
                        ((static_cast<int_t> (tab [dimfix - 2])) << 9) +
                        ((static_cast<int_t> (tab [dimfix - 3])) >> 1);
        }
} /* tCubeFix::hashkey2 */

template <int dimfix, class coordtype>
const char *tCubeFix<dimfix,coordtype>::name ()
{
        return "cube";
} /* tCubeFix::name */

template <int dimfix, class coordtype>
const char *tCubeFix<dimfix,coordtype>::pluralname ()
{
        return "cubes";
} /* tCubeFix::pluralname */

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

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

template <int dim1, int dim2, class coordtype>
inline tCubeFix<dim1+dim2,coordtype> operator *
        (const tCubeFix<dim1,coordtype> &c1,
        const tCubeFix<dim2,coordtype> &c2)
{
        coordtype coord [dim1 + dim2];
        c1. coord (coord);
        c2. coord (coord + dim1);
        return tCubeFix<dim1+dim2,coordtype> (coord);
} /* operator * */

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

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

template <int dimfix, class coordtype>
inline std::istream &operator >> (std::istream &in,
        tCubeFix<dimfix,coordtype> &c)
{
        return ReadCubeFix (in, c, dimfix);
} /* operator >> */

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

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


} // namespace homology
} // namespace chomp

#endif // _CHOMP_CUBES_CUBEFIX_H_