cubiset.h

Go to the documentation of this file.

 
 
 
// This file copyright (C) 1997-2016 by Pawel Pilarczyk.
//
// This file is part of the "chomp" program. It 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 3 of the License, or (at your option) any later version.
//
// This software 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,
// please, see <https://www.gnu.org/licenses/>.
 
// 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_