cubevar.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: October 24, 2013.
 
 
#ifndef _CHOMP_CUBES_CUBEVAR_H_
#define _CHOMP_CUBES_CUBEVAR_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 <class coordtype>
class tCellVar;
 
 
// --------------------------------------------------
// ----------- Cube with allocated memory -----------
// --------------------------------------------------
 
template <class coordtype>
class tCubeVar
{
public:
        typedef coordtype CoordType;
 
        typedef tCellVar<coordtype> CellType;
 
        static const int MaxDim = 50;
 
        typedef tWrapBase<coordtype> PointBase;
 
        tCubeVar ();
        
        tCubeVar (const coordtype *c, int dim);
 
        tCubeVar (int number, int dim);
 
        tCubeVar (const tCubeVar<coordtype> &c);
 
        tCubeVar<coordtype> &operator = (const tCubeVar<coordtype> &c);
 
        ~tCubeVar ();
 
        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 ();
 
        // --- friends: ---
 
        friend inline int operator == (const tCubeVar<coordtype> &c1,
                const tCubeVar<coordtype> &c2)
        {
                if (!c1. tab)
                        return c2. tab ? false : true;
                if (!c2. tab)
                        return false;
                return thesame (c1. tab, c2. tab, c1. tab [0] + 1);
        } /* operator == */
 
        // friend class: cubical cell
        friend class tCellVar<coordtype>;
 
private:
        coordtype *tab;
 
        coordtype *initialize (int dim);
 
}; /* class tCubeVar */
 
// --------------------------------------------------
 
template <class coordtype>
inline coordtype *tCubeVar<coordtype>::initialize (int d)
{
        tab = new coordtype [d + 1];
        if (!tab)
                throw "Not enough memory for a cube.";
        *tab = d;
        return (tab + 1);
} /* tCubeVar::initialize */
 
// --------------------------------------------------
 
template <class coordtype>
inline tCubeVar<coordtype>::tCubeVar ()
{
        tab = NULL;
        return;
} /* tCubeVar::tCubeVar */
 
template <class coordtype>
inline tCubeVar<coordtype>::tCubeVar (const coordtype *c, int d)
{
        if (d < 0)
                throw "Negative dimension of a cube.";
        if (d)
                PointBase::wrapcopy (initialize (d), c, d);
        else
                tab = NULL;
        return;
} /* tCubeVar::tCubeVar */
 
template <class coordtype>
inline tCubeVar<coordtype>::tCubeVar (int, int)
{
        throw "Unable to construct a cube from a number.";
} /* tCubeVar::tCubeVar */
 
template <class coordtype>
inline tCubeVar<coordtype>::tCubeVar (const tCubeVar<coordtype> &c)
{
        if (!c. dim ())
                tab = NULL;
        else
        {
                initialize (c. dim ());
                copycoord (tab + 1, c. tab + 1, c. dim ());
        }
        return;
} /* tCubeVar::tCubeVar */
 
template <class coordtype>
inline tCubeVar<coordtype> &tCubeVar<coordtype>::operator =
        (const tCubeVar<coordtype> &c)
{
        if (dim () == c. dim ())
                copycoord (tab + 1, c. tab + 1, dim ());
        else
        {
                if (tab)
                        delete [] tab;
                if (c. dim ())
                {
                        initialize (c. dim ());
                        copycoord (tab + 1, c. tab + 1, c. dim ());
                }
                else
                        tab = NULL;
        }
        return *this;
} /* tCubeVar::operator = */
 
template <class coordtype>
inline tCubeVar<coordtype>::~tCubeVar<coordtype> ()
{
        if (tab)
                delete [] tab;
        return;
} /* tCubeVar::~tCubeVar */
 
template <class coordtype>
inline int tCubeVar<coordtype>::dim () const
{
        return tab ? *tab : 0;
} /* tCubeVar::dim */
 
//template <class coordtype>
//template <class intType>
//inline intType *tCubeVar<coordtype>::coord (intType *c) const
//{
//      if (!tab)
//              return NULL;
//      for (int i = 0; i < *tab; ++ i)
//              c [i] = static_cast<const intType> (tab [i + 1]);
//      return c;
//} /* tCubeVar::coord */
 
template <class coordtype>
inline coordtype *tCubeVar<coordtype>::coord (coordtype *c) const
{
        if (!tab)
                return 0;
        for (int i = 0; i < *tab; ++ i)
                c [i] = tab [i + 1];
        return c;
} /* tCubeVar::coord */
 
template <class coordtype>
inline int_t tCubeVar<coordtype>::hashkey1 () const
{
        int d = dim ();
        switch (d)
        {
        case 0:
                return 0;
        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);
        }
} /* tCubeVar::hashkey1 */
 
template <class coordtype>
inline int_t hashkey1 (const tCubeVar<coordtype> &c)
{
        return c. hashkey1 ();
} /* hashkey1 */
 
template <class coordtype>
inline int_t tCubeVar<coordtype>::hashkey2 () const
{
        int d = dim ();
        switch (d)
        {
        case 0:
                return 1;
        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 [d - 1])) << 20) +
                        ((static_cast<int_t> (tab [d - 2])) << 9) +
                        ((static_cast<int_t> (tab [d - 3])) >> 1);
        }
} /* tCubeVar::hashkey2 */
 
template <class coordtype>
inline int_t hashkey2 (const tCubeVar<coordtype> &c)
{
        return c. hashkey2 ();
} /* hashkey2 */
 
template <class coordtype>
inline const char *tCubeVar<coordtype>::name ()
{
        return "cube";
} /* tCubeVar::name */
 
template <class coordtype>
inline const char *tCubeVar<coordtype>::pluralname ()
{
        return "cubes";
} /* tCubeVar::pluralname */
 
// --------------------------------------------------
 
template <class coordtype>
inline int operator != (const tCubeVar<coordtype> &c1,
        const tCubeVar<coordtype> &c2)
{
        return !(c1 == c2);
} /* operator != */
 
// --------------------------------------------------
 
template <class coordtype>
inline tCubeVar<coordtype> operator * (const tCubeVar<coordtype> &c1,
        const tCubeVar<coordtype> &c2)
{
        int dim1 = c1. dim (), dim2 = c2. dim ();
        if (dim1 + dim2 >= tCubeVar<coordtype>::MaxDim)
                throw "Dimension too high to concatenate coordinates.";
        coordtype coord [tCubeVar<coordtype>::MaxDim];
        c1. coord (coord);
        c2. coord (coord + dim1);
        return tCubeVar<coordtype> (coord, dim1 + dim2);
} /* operator * */
 
// --------------------------------------------------
 
template <class coordtype>
inline std::ostream &operator << (std::ostream &out,
        const tCubeVar<coordtype> &c)
{
        return WriteCube (out, c);
} /* operator << */
 
template <class coordtype>
inline std::istream &operator >> (std::istream &in, tCubeVar<coordtype> &c)
{
        return ReadCube (in, c);
} /* operator >> */
 
template <class coordtype>
inline std::istream &operator >> (std::istream &in,
        hashedset<tCubeVar<coordtype> > &s)
{
        return ReadCubes (in, s);
} /* operator >> */
 
template <class coordtype>
inline std::istream &operator >> (std::istream &in,
        mvmap<tCubeVar<coordtype>,tCubeVar<coordtype> > &m)
{
        return ReadCubicalMap (in, m);
} /* operator >> */
 
 
} // namespace homology
} // namespace chomp
 
#endif // _CHOMP_CUBES_CUBEVAR_H_