prodcell.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// A Cartesian product of simplicial cells of arbitrary type.
///
/////////////////////////////////////////////////////////////////////////////

// Copyright (C) 2009-2016 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 <http://www.gnu.org/licenses/>.

// Started on March 24, 2009. Last revision: August 20, 2013.


#ifndef _CHAINCON_PRODCELL_H_
#define _CHAINCON_PRODCELL_H_


// include some standard C++ header files
#include <istream>
#include <ostream>
#include <algorithm>
#include <vector>

// include selected header files from the CHomP library
#include "chomp/system/config.h"


// --------------------------------------------------
// ------------------ product cell ------------------
// --------------------------------------------------

/// A Cartesian product of simplicial cells as a simplicial cell.
template <class CellT>
class tProdCell
{
public:
        /// The type of the cells whose product is stored here.
        typedef CellT CellType;

        /// The type of the empty cell existence decision class.
        typedef typename CellT::EmptyType EmptyType;

        /// The default constructor of an undefined product cell.
        tProdCell ();

        /// The constructor of a product cell from a simplicial cell.
        tProdCell (const CellT &c);

        /// The constructor of a product of two product cells.
        tProdCell (const tProdCell<CellT> &s1, const tProdCell<CellT> &s2);

        /// The copy constructor.
        tProdCell (const tProdCell<CellT> &s);

        /// The constructor of the n-th face of a cell (if n >= 0)
        /// or the k-th degeneracy operator (if n = -1 - k < 0).
        tProdCell (const tProdCell<CellT> &s, int n);

        /// The assignment operator.
        tProdCell<CellT> &operator = (const tProdCell<CellT> &s);

        /// The destructor.
        ~tProdCell ();

        /// Checks if the two cells are equal.
        bool operator == (const tProdCell<CellT> &s) const;

        /// Swaps the data between two cells.
        void swap (tProdCell<CellT> &s);

        /// Returns the dimension of the cell.
        int dim () const;

        /// Checks if the product cell is degenerate, that is,
        /// if its (i-1)st face equals ith face.
        /// Returns the first such number i > 0 if this is the case.
        /// Returns 0 if the cell is not degenerate.
        /// Note that this verification may be a bit time-consuming,
        /// because it involves creation of all these faces.
        int degenerate () const;

        /// Checks if the cell is defined.
        bool defined () const;

        /// Checks if the cell is really a product of two other cells.
        /// Returns true if yes, or false otherwise.
        bool product () const;

        /// Returns the left-hand side part of the product.
        const tProdCell &getLeft () const;

        /// Returns the right-hand side part of the product.
        const tProdCell &getRight () const;

        /// Returns the actual cell in case this is not a product.
        const CellT &getCell () const;

        /// Returns the length of the boundary of the simplicial product,
        /// which equals the dimension of the cell + 1.
        int boundaryLength () const;

        /// Returns the n-th coefficient in the boundary
        /// of the simplicial product, which is (-1)^n.
        int boundaryCoef (int n) const;

private:
        /// The dimension of the cell.
        int dimension;

        /// A pointer to the left-hand side part of the product.
        tProdCell<CellT> *left;

        /// A pointer to the right-hand side part of the product.
        tProdCell<CellT> *right;

        /// A pointer to the actual cell if this is not a product.
        CellT *cell;

}; /* class tProdCell */

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

template <class CellT>
inline tProdCell<CellT>::tProdCell ():
        dimension (-1), left (0), right (0), cell (0)
{
        return;
} /* tProdCell::tProdCell */

template <class CellT>
inline tProdCell<CellT>::tProdCell (const CellT &c):
        dimension (c. dim ()), left (0), right (0), cell (new CellT (c))
{
        return;
} /* tProdCell::tProdCell */

template <class CellT>
inline tProdCell<CellT>::tProdCell (const tProdCell<CellT> &s1,
        const tProdCell<CellT> &s2): dimension (s1. dimension),
        left (new tProdCell<CellT> (s1)), right (new tProdCell<CellT> (s2)),
        cell (0)
{
        if (dimension != s2. dimension)
        {
                throw "Constructing a simplicial product of cells "
                        "of different dim.";
        }
        return;
} /* tProdCell::tProdCell */

template <class CellT>
inline tProdCell<CellT>::tProdCell (const tProdCell<CellT> &s):
        dimension (s. dimension),
        left (s. left ? new tProdCell<CellT> (*s. left) : 0),
        right (s. right ? new tProdCell<CellT> (*s. right) : 0),
        cell (s. cell ? new CellT (*s. cell) : 0)
{
        return;
} /* tProdCell::tProdCell */

template <class CellT>
inline tProdCell<CellT>::tProdCell (const tProdCell<CellT> &s, int n):
        dimension (-1),
        left (s. left ? new tProdCell<CellT> (*s. left, n) : 0),
        right (s. right ? new tProdCell<CellT> (*s. right, n) : 0),
        cell (s. cell ? new CellT (*s. cell, n) : 0)
{
        if (left)
                dimension = left -> dim ();
        else if (cell)
                dimension = cell -> dim ();
        return;
} /* tProdCell::tProdCell */

template <class CellT>
inline tProdCell<CellT> &tProdCell<CellT>::operator =
        (const tProdCell<CellT> &s)
{
        // if this is a statement like "x = x" then do nothing
        if (this == &s)
                return *this;

        // release the pointed-to cells
        if (left)
        {
                delete left;
                left = 0;
        }
        if (right)
        {
                delete right;
                right = 0;
        }
        if (cell)
        {
                delete cell;
                cell = 0;
        }

        // create new cells, copies of the other cells
        dimension = s. dimension;
        left = s. left ? new tProdCell<CellT> (*s. left) : 0;
        right = s. right ? new tProdCell<CellT> (*s. right) : 0;
        cell = s. cell ? new CellT (*s. cell) : 0;

        return *this;
} /* tProdCell::operator = */

template <class CellT>
inline tProdCell<CellT>::~tProdCell ()
{
        if (left)
                delete left;
        if (right)
                delete right;
        if (cell)
                delete cell;
        return;
} /* tProdCell::~tProdCell */

template <class CellT>
inline bool tProdCell<CellT>::operator ==
        (const tProdCell<CellT> &s) const
{
        if (dimension != s. dimension)
                return false;
        if ((left && !s. left) || (!left && s. left))
                return false;
        if (left && !(*left == *s. left))
                return false;
        if ((right && !s. right) || (!right && s. right))
                return false;
        if (right && !(*right == *s. right))
                return false;
        if ((cell && !s. cell) || (!cell && s. cell))
                return false;
        if (cell && !(*cell == *s. cell))
                return false;
        return true;
} /* tProdCell::operator == */

template <class CellT>
inline void tProdCell<CellT>::swap (tProdCell<CellT> &s)
{
        std::swap (dimension, s. dimension);
        std::swap (left, s. left);
        std::swap (right, s. right);
        std::swap (cell, s. cell);
        return;
} /* tProdCell::swap */

template <class CellT>
inline int tProdCell<CellT>::dim () const
{
        return dimension;
} /* tProdCell::dim */

template <class CellT>
inline int tProdCell<CellT>::degenerate () const
{
        if (dimension < 1)
                return 0;
        tProdCell<CellT> bd1 (*this, 0);
        for (int i = 1; i <= dimension; ++ i)
        {
                tProdCell<CellT> bd2 (*this, i);
                if (bd1 == bd2)
                        return i;
                bd1. swap (bd2);
        }
        return 0;
} /* tProdCell::degenerate */

template <class CellT>
inline bool tProdCell<CellT>::defined () const
{
        return (left || cell);
} /* tProdCell::defined */

template <class CellT>
inline bool tProdCell<CellT>::product () const
{
        return !!left;
} /* tProdCell::product */

template <class CellT>
inline const tProdCell<CellT> &tProdCell<CellT>::getLeft () const
{
        if (!left)
                throw "Trying to get a non-existent left cell from a product.";
        return *left;
} /* tProdCell::getLeft */

template <class CellT>
inline const tProdCell<CellT> &tProdCell<CellT>::getRight () const
{
        if (!right)
                throw "Trying to get a non-existent right cell from a product.";
        return *right;
} /* tProdCell::getRight */

template <class CellT>
inline const CellT &tProdCell<CellT>::getCell () const
{
        if (!cell)
                throw "Trying to get a non-existent cell from a product.";
        return *cell;
} /* tProdCell::getCell */

template <class CellT>
inline int tProdCell<CellT>::boundaryLength () const
{
        return (dimension > 0) ? (dimension + 1) : 0;
} /* tProdCell::boundaryLength */

template <class CellT>
inline int tProdCell<CellT>::boundaryCoef (int n) const
{
        return (n & 1) ? -1 : 1;
} /* tProdCell::boundaryCoef */

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

/// Generates a hashing key no. 1 for a product cell,
/// composed of hashing keys for the cells in the product.
/// This key is to be used in a hashed set.
template <class CellT>
inline int_t hashkey1 (const tProdCell<CellT> &s)
{
//      using chomp::homology::hashkey1;
        using ::hashkey1;

        if (!s. defined ())
                return 0;
        if (s. product ())
        {
                return (hashkey1 (s. getLeft ()) << 11) ^
                        hashkey1 (s. getRight ());
        }
        return hashkey1 (s. getCell ());
} /* hashkey1 */

/// Generates a hashing key no. 2 for a product cell,
/// composed of hashing keys for the cells in the product.
/// This key is to be used in a hashed set.
template <class CellT>
inline int_t hashkey2 (const tProdCell<CellT> &s)
{
//      using chomp::homology::hashkey2;
        using ::hashkey2;

        if (!s. defined ())
                return 0;
        if (s. product ())
        {
                return hashkey2 (s. getLeft ()) ^
                        (hashkey2 (s. getRight ()) << 13);
        }
        return hashkey2 (s. getCell ());
} /* hashkey2 */

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

/// Writes a product cell in the text mode to an output stream.
template <class CellT>
std::ostream &operator << (std::ostream &out, const tProdCell<CellT> &s)
{
        if (!s. defined ())
                out << "[undef]";
        else if (s. product ())
        {
                out << "(" << s. getLeft () << " X " <<
                        s. getRight () << ")";
        }
        else
                out << s. getCell ();

        return out;
} /* operator << */

/// Reading a product cell is not well defined (too much effort, sorry!).
template <class CellT>
std::istream &operator >> (std::istream &in, tProdCell<CellT> &s)
{
        throw "Reading a product cell not programmed. Sorry!";
        return in;
} /* operator >> */


#endif // _CHAINCON_PRODCELL_H_