cubiset.h

Go to the documentation of this file.

// Copyright (C) 1997-2010 by Pawel Pilarczyk.
//
// This file constitutes a part of the Homology Library, 
// distributed under the terms of the GNU General Public License.
// Consult  http://capd.wsb-nlu.edu.pl/ for details. 

// Started on March 19, 2006. Last revision: July 27, 2007.


#ifndef _CAPD_HOMENGIN_CUBISET_H_ 
#define _CAPD_HOMENGIN_CUBISET_H_ 

#include <string>
#include <cstring>
#include "capd/homengin/homology.h"


// --------------------------------------------------
// ------------------ CUBICAL SET -------------------
// --------------------------------------------------

class CubicalSet
{
public:
        CubicalSet (const int *left_coords, const int *right_coords,
                int dim = EMBEDDING_DIM, const int *space_wrapping = 0);

        ~CubicalSet ();

        CubicalSet (const CubicalSet &c);

        CubicalSet &operator = (const CubicalSet &c);

        void ComputeBettiNumbers (int *result, const char *engine = 0,
                bool quiet = false) const;

        int Add (const int *coords);

        int Delete (const int *coords);

        bool Contains (const int *coords) const;

        void Clear ();

private:
        int ByteOffset (const int *coords) const;

        int BitMask (const int *coords) const;

        bool Inside (const int *coords);

        unsigned char *buffer;

        int bufsize;

        int dim;

        int *sizes;

        int *minimal;

        int *wrapping;

}; /* class CubicalComples */

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

inline CubicalSet::CubicalSet (const int *left_coords,
        const int *right_coords, int dim, const int *space_wrapping)
{
        if (dim <= 0)
                throw "Non-positive dimension of a cubical complex.";
        this -> dim = dim;
        this -> sizes = new int [dim];
        this -> minimal = new int [dim];
        this -> wrapping = space_wrapping ? new int [dim] : 0;
        this -> bufsize = 0;
        for (int i = 0; i < dim; ++ i)
        {
                minimal [i] = left_coords [i];
                sizes [i] = right_coords [i] - left_coords [i];
                if (sizes [i] <= 0)
                        throw "Non-positive size of a cubical complex.";
                if (!i)
                {
                        sizes [0] = (sizes [0] + 63) & ~63;
                        bufsize = sizes [0] >> 3;
                }
                else
                        bufsize *= sizes [i];
        }
        if (space_wrapping)
        {
                for (int i = 0; i < dim; ++ i)
                {
                        wrapping [i] = space_wrapping [i];
                        if (wrapping [i] < 0)
                                wrapping [i] = -space_wrapping [i];
                }
        }
        if (bufsize <= 0)
                throw "Wrong buffer size in a cubical complex.";
        buffer = new unsigned char [bufsize];
        std::memset (buffer, 0, bufsize);
        return;
} /* CubicalSet::CubicalSet */

inline CubicalSet::~CubicalSet ()
{
        delete [] sizes;
        delete [] minimal;
        delete [] buffer;
        if (wrapping)
                delete [] wrapping;
        return;
} /* CubicalSet::~CubicalSet */

inline CubicalSet::CubicalSet (const CubicalSet &c)
{
        dim = c. dim;
        bufsize = c. bufsize;
        sizes = new int [dim];
        minimal = new int [dim];
        for (int i = 0; i < dim; ++ i)
        {
                minimal [i] = c. minimal [i];
                sizes [i] = c. sizes [i];
        }
        buffer = new unsigned char [bufsize];
        std::memcpy (buffer, c. buffer, bufsize);
        return;
} /* CubicalSet::CubicalSet */

inline CubicalSet &CubicalSet::operator = (const CubicalSet &c)
{
        delete [] sizes;
        delete [] minimal;
        delete [] buffer;

        dim = c. dim;
        bufsize = c. bufsize;
        sizes = new int [dim];
        minimal = new int [dim];
        for (int i = 0; i < dim; ++ i)
        {
                minimal [i] = c. minimal [i];
                sizes [i] = c. sizes [i];
                if (i > 0)
                        bufsize *= sizes [i];
        }
        buffer = new unsigned char [bufsize];
        std::memcpy (buffer, c. buffer, bufsize);
        return *this;
} /* CubicalSet::operator = */

inline int CubicalSet::ByteOffset (const int *coords) const
{
        int offset = (coords [0] - minimal [0]) >> 3;
        int multiply = ((sizes [0] + 31) >> 5) << 2;
        for (int i = 1; i < dim; ++ i)
        {
                offset += multiply * (coords [i] - minimal [i]);
                multiply *= sizes [i];
        }
        return offset;
} /* CubicalSet::ByteOffset */

inline int CubicalSet::BitMask (const int *coords) const
{
        return 1 << ((coords [0] - minimal [0]) & 0x07);
} /* CubicalSet::BitMask */

inline bool CubicalSet::Inside (const int *coords)
{
        for (int i = 0; i < dim; ++ i)
        {
                if (coords [i] < minimal [i])
                        return false;
                if (coords [i] >= minimal [i] + sizes [i])
                        return false;
        }
        return true;
} /* CubicalSet::Inside */

inline int CubicalSet::Add (const int *coords)
{
        if (!Inside (coords))
                return -1;
        buffer [ByteOffset (coords)] |= BitMask (coords);
        return 0;
} /* CubicalSet::Add */

inline int CubicalSet::Delete (const int *coords)
{
        if (!Inside (coords))
                return -1;
        buffer [ByteOffset (coords)] &= ~(BitMask (coords));
        return 0;
} /* CubicalSet::Delete */

inline bool CubicalSet::Contains (const int *coords) const
{
        return buffer [ByteOffset (coords)] & BitMask (coords);
} /* CubicalSet::Contains */

inline void CubicalSet::Clear ()
{
        std::memset (buffer, 0, bufsize);
        return;
} /* CubicalSet::Clear */

inline void CubicalSet::ComputeBettiNumbers (int *result,
        const char *engine, bool quiet) const
{
	::ComputeBettiNumbers (buffer, sizes, dim, result, engine,
                wrapping, quiet);
        return;
} /* CubicalSet::ComputeBettiNumbers */

inline void ComputeBettiNumbers (const CubicalSet &s, int *result,
        const char *engine = 0, bool quiet = false)
{
        s. ComputeBettiNumbers (result, engine, quiet);
        return;
} /* ComputeBettiNumbers */


#endif // _CAPD_HOMENGIN_CUBISET_H_