pointbas.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: January 23, 2010.


#ifndef _CHOMP_CUBES_POINTBAS_H_
#define _CHOMP_CUBES_POINTBAS_H_

#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
#include "chomp/cubes/pointset.h"

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


namespace chomp {
namespace homology {


// classes defined within this header file (in this order):
template <class coordtype>
class tPointBase;

template <class coordtype>
class tPointBaseInitializer;

typedef tPointBase<coordinate> PointBase;

const int DimBits = (sizeof (int_t) > 4) ? 7 : 6;

const int NumBits = (sizeof (int_t) << 3) - DimBits;

const int_t SignBit = static_cast<int_t> (1) << ((sizeof (int_t) << 3) - 1);

const int_t NumMask = (~(static_cast<int_t> (0) ^ SignBit)) >> (DimBits - 1);

const int MaxBasDim1 = static_cast<int> (1u << (DimBits - 1));

const int MaxBasDim2 = static_cast<int> ((sizeof (int_t) << 3) - DimBits);

const int MaxBasDim = (MaxBasDim1 < MaxBasDim2) ? MaxBasDim1 : MaxBasDim2;


// --------------------------------------------------
// ------------------- Point Base -------------------
// --------------------------------------------------

template <class coordtype>
class tPointBase
{
public:
        static int_t number (const coordtype *c, int d);

        static bool check (const coordtype *c, int d);

        static const coordtype *coord (int_t number, int d);

        static int defaultdimension (void);

        static void quiet (bool what = true);
        
        static void setwrapping (const coordtype *c,
                int mindim = 1, int maxdim = MaxBasDim);

        static void setwrapping (coordtype c,
                int mindim = 1, int maxdim = MaxBasDim);

        static const coordtype *getwrapping (int d);

        static void wrapcoord (coordtype *c, int dim);

        static void wrapcopy (coordtype *dest, const coordtype *src,
                int dim);

        static void reset (void);

        static void forget (void);

        static outputstream &showused (outputstream &out);

        static std::ostream &showused (std::ostream &out);

        friend class tPointBaseInitializer<coordtype>;

protected:
        static tPointset<coordtype> **p;

        static int n;

        static bool show;

        static bool forgotten;

        static tPointBaseInitializer<coordtype> pointBaseInitializer;

}; /* class tPointBase */

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

template <class coordtype>
inline const coordtype *tPointBase<coordtype>::coord (int_t nr, int d)
{
        if (forgotten)
                throw "Trying to retrieve forgotten coordinates.";
        if ((d > n) || (d <= 0) || (p [d - 1] == NULL))
                return NULL;
        else
                return (*(p [d - 1])) [nr];
} /* tPointBase::coord */

template <class coordtype>
inline bool tPointBase<coordtype>::check (const coordtype *c, int d)
{
        if (forgotten)
                throw "Trying to check forgotten coordinates.";
        if ((d > n) || (d <= 0) || (p [d - 1] == NULL))
                return 0;
        return p [d - 1] -> check (c);
} /* tPointBase::check */

template <class coordtype>
inline void tPointBase<coordtype>::quiet (bool what)
{
        show = !what;
        return;
} /* tPointBase::quiet */

template <class coordtype>
inline int_t tPointBase<coordtype>::number (const coordtype *c, int d)
{
        if (forgotten)
                throw "Trying to find the number of forgotten coordinates.";

        if (d < 0)
                return -1;
        if (d >= MaxBasDim)
                throw "Dimension too high.";

        // enhance the table of sets of points if necessary
        if (d > n)
        {
                tPointset<coordtype> **newtable =
                        new tPointset<coordtype> * [d];
                for (int i = 0; i < d; ++ i)
                        newtable [i] = (i < n) ? p [i] : NULL;
                if (p)
                        delete [] p;
                p = newtable;
                n = d;
        }

        if (!p [d - 1])
        {
                p [d - 1] = new tPointset<coordtype> (1024);
                p [d - 1] -> dimension (d);
        }

        int_t number = p [d - 1] -> add (c);
        if (number > NumMask)
                throw "Too many points.";

        return number;
} /* tPointBase::number */

template <class coordtype>
inline void tPointBase<coordtype>::setwrapping (const coordtype *c,
        int mindim, int maxdim)
{
        if (forgotten)
                throw "Trying to wrap forgotten coordinates.";

        // correct the left and right bound for dimensions
        if (mindim < 1)
                mindim = 1;
        if (maxdim > MaxBasDim)
                maxdim = MaxBasDim;

        // enhance the table of sets of points if necessary
        if (maxdim > n)
        {
                tPointset<coordtype> **newtable =
                        new tPointset<coordtype> * [maxdim];
                for (int i = 0; i < maxdim; ++ i)
                        newtable [i] = (i < n) ? p [i] : NULL;
                if (p)
                        delete [] p;
                p = newtable;
                n = maxdim;
        }

        // set wrapping coordinates and allocate sets of points if needed
        for (int d = mindim; d < maxdim; ++ d)
        {
                if (!p [d - 1])
                {
                        p [d - 1] = new tPointset<coordtype>;
                        p [d - 1] -> dimension (d);
                }
                p [d - 1] -> wrapspace (c);
        }

        return;
} /* tPointBase::setwrapping */

template <class coordtype>
inline void tPointBase<coordtype>::setwrapping (coordtype c,
        int mindim, int maxdim)
{
        coordtype wraptable [MaxBasDim];
        for (int i = 0; i < MaxBasDim; ++ i)
                wraptable [i] = c;
        setwrapping (wraptable, mindim, maxdim);
        return;
} /* tPointBase::setwrapping */

template <class coordtype>
inline const coordtype *tPointBase<coordtype>::getwrapping (int d)
{
        if (forgotten)
                throw "Trying to get wrapping of forgotten coordinates.";

        if ((d <= 0) || (d - 1 >= n) || !p [d - 1])
                return NULL;
        else
                return p [d - 1] -> wrapspace ();
} /* tPointBase::getwrapping */

template <class coordtype>
inline void tPointBase<coordtype>::wrapcoord (coordtype *c, int dim)
{
        if ((dim > n) || (dim <= 0) || (p [dim - 1] == NULL))
                return;
        const coordtype *cw = p [dim - 1] -> wrapspace ();
        if (cw)
                chomp::homology::wrapcoord (c, c, cw, dim);
        return;
} /* tPointBase::wrapcoord */

template <class coordtype>
inline void tPointBase<coordtype>::wrapcopy (coordtype *dest,
        const coordtype *src, int dim)
{
        const coordtype *cw;
        if ((dim > n) || (dim <= 0) || (p [dim - 1] == 0))
                cw = 0;
        else
                cw = p [dim - 1] -> wrapspace ();
        if (cw)
                chomp::homology::wrapcoord (dest, src, cw, dim);
        else
                copycoord (dest, src, dim);
        return;
} /* tPointBase::wrapcopy */

template <class coordtype>
inline void tPointBase<coordtype>::reset (void)
{
        for (int i = 0; i < n; ++ i)
        {
                if (p [i])
                {
                        delete p [i];
                        p [i] = NULL;
                }
        }
        delete [] p;
        p = NULL;
        n = 0;
        forgotten = false;
        return;
} /* tPointBase::reset */

template <class coordtype>
inline void tPointBase<coordtype>::forget (void)
{
        if (forgotten)
                throw "Trying to forget already forgotten coordinates.";

        reset ();
        forgotten = true;
        return;
} /* tPointBase::forget */

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

template <class coordtype>
tPointset<coordtype> **tPointBase<coordtype>::p = NULL;

template <class coordtype>
int tPointBase<coordtype>::n = 0;

template <class coordtype>
bool tPointBase<coordtype>::show = true;

template <class coordtype>
bool tPointBase<coordtype>::forgotten = false;

template <class coordtype>
int tPointBase<coordtype>::defaultdimension (void)
{
        static int dim = 0;
        if (dim)
                return dim;
        for (int d = 1; d <= n; ++ d)
        {
                if (!p [d - 1])
                        continue;
                if (p [d - 1] -> empty ())
                        continue;
                return d;
        }
        return 0;
} /* tPointBase::defaultdimension */

template <class coordtype>
outputstream &tPointBase<coordtype>::showused (outputstream &out)
{
        if (forgotten)
                throw "Trying to show forgotten coordinates.";

        bool shown = false;
        for (int i = 0; i < n; ++ i)
        {
                if (!p [i])
                        continue;
                const tPointset<coordtype> &pset = *(p [i]);
                if (pset. empty ())
                        continue;
                out << (shown ? ", " : "Vertices used: ") <<
                        pset. size () << " of dim " << (i + 1);
                shown = true;
        }
        if (shown)
                out << ".\n";
        return out;
} /* tPointBase::showused */

template <class coordtype>
std::ostream &tPointBase<coordtype>::showused (std::ostream &out)
{
        outputstream tout (out);
        showused (tout);
        return out;
} /* tPointBase::showused */


// --------------------------------------------------
// ------------- Point Base Initializer -------------
// --------------------------------------------------

template <class coordtype>
class tPointBaseInitializer
{
public:
        ~tPointBaseInitializer ();

}; /* PointBaseInitializer */

template <class coordtype>
tPointBaseInitializer<coordtype> tPointBase<coordtype>::pointBaseInitializer;

template <class coordtype>
tPointBaseInitializer<coordtype>::~tPointBaseInitializer<coordtype> ()
{
        if (tPointBase<coordtype>::forgotten)
                return;
        if (tPointBase<coordtype>::show && tPointBase<coordtype>::n)
                tPointBase<coordtype>::showused (sout);
        tPointBase<coordtype>::forget ();
        return;
} /* PointBaseInitializer::~PointBaseInitializer */


// --------------------------------------------------
// ------------------- Wrap Base --------------------
// --------------------------------------------------

template <class coordtype>
class tWrapBase: public tPointBase<coordtype>
{
public:
        static int_t number (const coordtype *, int)
                {throw "Trying to get a point number.";}

        static bool check (const coordtype *, int)
                {return true;}

        static const coordtype *coord (int_t, int)
                {throw "Trying to get the coordinates of a point.";}

        static void quiet (bool = true) {return;}

        static void reset (void) {return;}

        static void forget (void) {return;}

        static outputstream &showused (outputstream &out) {return out;}

        static std::ostream &showused (std::ostream &out) {return out;}

}; /* class tWrapBase */

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


} // namespace homology
} // namespace chomp

#endif // _CHOMP_CUBES_POINTBAS_H_