cellfix.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_CELLFIX_H_
#define _CHOMP_CUBES_CELLFIX_H_
 
#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
#include "chomp/cubes/pointset.h"
#include "chomp/homology/chains.h"
#include "chomp/struct/bitfield.h"
#include "chomp/struct/integer.h"
#include "chomp/struct/hashsets.h"
#include "chomp/homology/gcomplex.h"
#include "chomp/cubes/pointbas.h"
#include "chomp/cubes/cubefix.h"
#include "chomp/cubes/cellmain.h"
 
#include <iostream>
#include <fstream>
#include <cstdlib>
 
namespace chomp {
namespace homology {
 
 
// --------------------------------------------------
// ----------- CubicalCell with fixed dim -----------
// --------------------------------------------------
 
template <int dimfix, class coordtype>
class tCellFix
{
public:
        typedef coordtype CoordType;
 
        static const int MaxDim =
                (tCubeFix<dimfix,coordtype>::MaxDim < MaxBasDim) ?
                tCubeFix<dimfix,coordtype>::MaxDim : MaxBasDim;
 
        static const int MaxSpaceDim = dimfix;
 
        typedef typename tCubeFix<dimfix,coordtype>::PointBase PointBase;
 
        tCellFix ();
        
        tCellFix (const coordtype *c1, const coordtype *c2,
                int spcdim = 0, int celldim = -1);
 
        tCellFix (const tCubeFix<dimfix,coordtype> &q1,
                const tCubeFix<dimfix,coordtype> &q2);
 
        tCellFix (const tCubeFix<dimfix,coordtype> &q, int facedim);
 
        explicit tCellFix (const tCubeFix<dimfix,coordtype> &q);
 
        template <int dimhigh>
        tCellFix (const tCellFix<dimhigh,coordtype> &q,
                int offset, int ncoords);
 
        tCellFix (const tCellFix<dimfix,coordtype> &c);
 
        tCellFix<dimfix,coordtype> &operator =
                (const tCellFix<dimfix,coordtype> &c);
 
        int dim () const;
 
        int spacedim () const;
 
        coordtype *leftcoord (coordtype *c) const;
 
        coordtype *rightcoord (coordtype *c) const;
 
        int_t hashkey1 () const;
 
        int_t hashkey2 () const;
 
        static const char *name ();
 
        static const char *pluralname ();
 
        enum OutputBitValues
        {
                BitProduct = 0x01,      // unset => two vertices
                BitSpace = 0x02
        };
 
        static int OutputBits;
 
        // --- friends: ---
 
        template <int _dimfix, class _coordtype>
        friend inline int operator ==
                (const tCellFix<_dimfix,_coordtype> &c1,
                const tCellFix<_dimfix,_coordtype> &c2)
        {
                return ((c1. n == c2. n) && (!memcmp (c1. tab, c2. tab,
                        dimfix * sizeof (coordtype))));
        } /* operator == */
 
private:
        coordtype tab [dimfix];
 
        int_t n;
 
        void initialize (const coordtype *c1, const coordtype *c2,
                int celldim = -1);
 
}; /* class tCellFix */
 
// --------------------------------------------------
 
template <int dimfix, class coordtype>
int tCellFix<dimfix,coordtype>::OutputBits = 0;
 
// --------------------------------------------------
 
template <int dimfix, class coordtype>
inline void tCellFix<dimfix,coordtype>::initialize (const coordtype *c1,
        const coordtype *c2, int celldim)
{
        // copy the left corner coordinates to the cell
        PointBase::wrapcopy (tab, c1, dimfix);
 
        // prepare wrapped right coordinates for the detection of cell bits
        coordtype r [dimfix];
        PointBase::wrapcopy (r, c2, dimfix);
 
        // if the dimension of the cell is known, then compute the bits only
        if (celldim >= 0)
        {
                n = static_cast<int_t> (celldim) << NumBits;
                if (!celldim)
                        return;
                for (int i = 0; i < dimfix; ++ i)
                {
                        if (tab [i] != r [i])
                                n |= (static_cast<int_t> (1) << i);
                }
                return;
        }
 
        // set the bits of the cell and compute its actual dimension
        n = 0;
        int dim = 0;
        for (int i = 0; i < dimfix; ++ i)
        {
                if (tab [i] != r [i])
                {
                        n |= (static_cast<int_t> (1) << i);
                        ++ dim;
                }
        }
        n |= static_cast<int_t> (dim) << NumBits;
 
        return;
} /* tCellFix::initialize */
 
// --------------------------------------------------
 
template <int dimfix, class coordtype>
inline tCellFix<dimfix,coordtype>::tCellFix ()
:n (0)
{
        if (dimfix > MaxDim)
                throw "Too high fixed-dim cell dimension.";
        return;
} /* tCellFix::tCellFix */
 
template <int dimfix, class coordtype>
inline tCellFix<dimfix,coordtype>::tCellFix
        (const coordtype *c1, const coordtype *c2, int spcdim, int celldim)
{
        // test the validity of the dimension
        if (spcdim < 0)
                throw "Negative dimension of the space.";
        else if ((spcdim > 0) && (spcdim != dimfix))
                throw "Wrong dimension of a cell.";
        if (dimfix > MaxDim)
                throw "Too high fixed-dim cell dimension.";
 
        // initialize the cell
        initialize (c1, c2, celldim);
        return;
} /* tCellFix::tCellFix */
        
template <int dimfix, class coordtype>
inline tCellFix<dimfix,coordtype>::tCellFix
        (const tCubeFix<dimfix,coordtype> &q1,
        const tCubeFix<dimfix,coordtype> &q2)
{
        if (dimfix > MaxDim)
                throw "Too high fixed-dim cell dimension.";
 
        // get the coordinates of minimal vertices of both cubes
        coordtype c1 [dimfix];
        q1. coord (c1);
        coordtype c2 [dimfix];
        q2. coord (c2);
 
        // prepare tables for the new coordinates of the cubical cell
        coordinate left [dimfix];
        coordinate right [dimfix];
 
        // compute the new coordinates of the cubical cell
        int celldim = CommonCell (left, right, c1, c2, dimfix,
                PointBase::getwrapping (dimfix));
        
        // create the cell as computed
        initialize (left, right, celldim);
 
        return;
} /* tCellFix::tCellFix */
 
template <int dimfix, class coordtype>
inline tCellFix<dimfix,coordtype>::tCellFix
        (const tCubeFix<dimfix,coordtype> &q, int facedim)
{
        if (facedim < 0)
                throw "Negative dimension of a face requested.";
        if (facedim > dimfix)
                throw "Too high dimension of a face requested.";
        if (dimfix > MaxDim)
                throw "Too high fixed-dim cell dimension.";
        copycoord (tab, q. tab, dimfix);
        n = static_cast<int_t> (facedim) << NumBits;
        for (int i = 0; i < facedim; ++ i)
                n |= static_cast<int_t> (1) << i;
        return;
} /* tCellFix::tCellFix */
 
template <int dimfix, class coordtype>
inline tCellFix<dimfix,coordtype>::tCellFix
        (const tCubeFix<dimfix,coordtype> &q)
: n ((static_cast<int_t> (dimfix) << NumBits) | NumMask)
{
        if (dimfix > MaxDim)
                throw "Too high fixed-dim cell dimension.";
        copycoord (tab, q. tab, dimfix);
        return;
} /* tCellFix::tCellFix */
 
template <int dimfix, class coordtype>
template <int dimhigh>
inline tCellFix<dimfix,coordtype>::tCellFix
        (const tCellFix<dimhigh,coordtype> &q, int offset, int ncoords)
{
        if ((offset < 0) || (ncoords <= 0) || (ncoords != dimfix) ||
                (offset + ncoords > dimhigh))
                throw "Wrong cell projection requested.";
        // note: the following can be done in a slightly more efficient way,
        // without creating the right coordinates and calling "initialize"
        coordtype right [dimhigh];
        q. rightcoord (right);
        initialize (q. tab + offset, right + offset);
        return;
} /* tCellFix::tCellFix */
 
template <int dimfix, class coordtype>
inline tCellFix<dimfix,coordtype>::tCellFix
        (const tCellFix<dimfix,coordtype> &q)
: n (q. n)
{
        copycoord (tab, q. tab, dimfix);
        return;
} /* tCellFix::tCellFix */
 
template <int dimfix, class coordtype>
inline tCellFix<dimfix,coordtype> &tCellFix<dimfix,coordtype>::operator =
        (const tCellFix<dimfix,coordtype> &q)
{
        memcpy (tab, q. tab, dimfix * sizeof (coordtype));
        n = q. n;
        return *this;
} /* tCellFix::operator = */
 
template <int dimfix, class coordtype>
inline int tCellFix<dimfix,coordtype>::dim () const
{
        return static_cast<int> (n >> NumBits);
} /* tCellFix::dim */
 
template <int dimfix, class coordtype>
inline int tCellFix<dimfix,coordtype>::spacedim () const
{
        return dimfix;
} /* tCellFix::spacedim */
 
template <int dimfix, class coordtype>
inline coordtype *tCellFix<dimfix,coordtype>::leftcoord (coordtype *c) const
{
        if (!c)
                throw "Null pointer to save left coordinates.";
        for (int i = 0; i < dimfix; ++ i)
                c [i] = tab [i];
        return c;
} /* tCellFix::leftcoord */
 
template <int dimfix, class coordtype>
inline coordtype *tCellFix<dimfix,coordtype>::rightcoord (coordtype *c) const
{
        if (!c)
                throw "Null pointer to save right coordinates.";
        for (int i = 0; i < dimfix; ++ i)
        {
                c [i] = tab [i] +
                        ((n & (static_cast<int_t> (1) << i)) ? 1 : 0);
        }
        PointBase::wrapcoord (c, spacedim ());
        return c;
} /* tCellFix::rightcoord */
 
template <int dimfix, class coordtype>
inline int_t tCellFix<dimfix,coordtype>::hashkey1 () const
{
        switch (dimfix)
        {
        case 1:
                return (static_cast<int_t> (tab [0]) << 12) ^ n;
        case 2:
                return (((static_cast<int_t> (tab [0])) << 18) +
                        ((static_cast<int_t> (tab [1])) << 6)) ^ n;
        default:
                return (((static_cast<int_t> (tab [0])) << 18) +
                        ((static_cast<int_t> (tab [1])) << 6) +
                        ((static_cast<int_t> (tab [2])) >> 6)) ^ n;
        }
} /* tCellFix::hashkey1 */
 
template <int dimfix, class coordtype>
inline int_t hashkey1 (const tCellFix<dimfix,coordtype> &c)
{
        return c. hashkey1 ();
} /* hashkey1 */
 
template <int dimfix, class coordtype>
inline int_t tCellFix<dimfix,coordtype>::hashkey2 () const
{
        switch (dimfix)
        {
        case 1:
                return (static_cast<int_t> (tab [0]) << 3) ^ (n << 5);
        case 2:
                return ((static_cast<int_t> (tab [0]) >> 1) +
                        (static_cast<int_t> (tab [1]) << 13)) ^ (n << 5);
        default:
                return (((static_cast<int_t> (tab [dimfix - 1])) << 20) +
                        ((static_cast<int_t> (tab [dimfix - 2])) << 9) +
                        ((static_cast<int_t> (tab [dimfix - 3])) >> 1)) ^
                        (n << 5);
        }
} /* tCellFix::hashkey2 */
 
template <int dimfix, class coordtype>
inline int_t hashkey2 (const tCellFix<dimfix,coordtype> &c)
{
        return c. hashkey2 ();
} /* hashkey2 */
 
template <int dimfix, class coordtype>
const char *tCellFix<dimfix,coordtype>::name ()
{
        return "cubical cell";
} /* tCellFix::name */
 
template <int dimfix, class coordtype>
const char *tCellFix<dimfix,coordtype>::pluralname ()
{
        return "cubical cells";
} /* tCellFix::pluralname */
 
// --------------------------------------------------
 
template <int dimfix, class coordtype>
inline int operator != (const tCellFix<dimfix,coordtype> &c1,
        const tCellFix<dimfix,coordtype> &c2)
{
        return !(c1 == c2);
} /* operator != */
 
// --------------------------------------------------
 
template <int dim1, int dim2, class coordtype>
inline tCellFix<dim1+dim2,coordtype> operator *
        (const tCellFix<dim1,coordtype> &c1,
        const tCellFix<dim2,coordtype> &c2)
{
        // prepare arrays for the coordinates of the cell to create
        coordtype left [dim1 + dim2];
        coordtype right [dim1 + dim2];
 
        // extract the coordinates of the first cell
        c1. leftcoord (left);
        c1. rightcoord (right);
 
        // extract the coordinates of the second cell
        c2. leftcoord (left + dim1);
        c2. rightcoord (right + dim1);
 
        // create the Cartesian product of the cells
        return tCellFix<dim1+dim2,coordtype> (left, right,
                dim1 + dim2, c1. dim () + c2. dim ());
} /* operator * */
 
template <int dimfix, class coordtype>
inline std::ostream &operator << (std::ostream &out,
        const tCellFix<dimfix,coordtype> &c)
{
        return WriteCubicalCell (out, c);
} /* operator << */
 
template <int dimfix, class coordtype>
inline std::istream &operator >> (std::istream &in,
        tCellFix<dimfix,coordtype> &c)
{
        return ReadCubicalCell (in, c);
} /* operator >> */
 
// --------------------------------------------------
 
template <int dimfix, class coordtype>
inline tCellFix<dimfix,coordtype> boundarycell
        (const tCellFix<dimfix,coordtype> &q, int i, bool onlyexisting)
{
        return CubicalBoundaryCell (q, i, onlyexisting);
} /* boundarycell */
 
template <int dimfix, class coordtype>
inline tCellFix<dimfix,coordtype> boundarycell
        (const tCellFix<dimfix,coordtype> &q, int i)
{
        return CubicalBoundaryCell (q, i);
} /* boundarycell */
        
template <int dimfix, class coordtype>
inline int boundarylength (const tCellFix<dimfix,coordtype> &q)
{
        return CubicalBoundaryLength (q);
} /* boundarylength */
 
template <int dimfix, class coordtype>
inline int boundarycoef (const tCellFix<dimfix,coordtype> &q, int i)
{
        return CubicalBoundaryCoef (q, i);
} /* boundarycoef */
 
 
} // namespace homology
} // namespace chomp
 
#endif // _CHOMP_CUBES_CELLFIX_H_