pointbas.h

Go to the documentation of this file.

 
 
 
// Copyright (C) 1997-2020 by Pawel Pilarczyk.
//
// This file is part of my research software package. This 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 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;
                dim = d;
                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_