algcell.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// An abstract algebraic cell.
///
/////////////////////////////////////////////////////////////////////////////

// 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: June 20, 2012.


#ifndef _CHAINCON_ALGCELL_H_
#define _CHAINCON_ALGCELL_H_


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

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

// include relevant local header files
#include "chaincon/chain.h"


// --------------------------------------------------
// ------------ abstract algebraic cell -------------
// --------------------------------------------------

/// An abstract algebraic cell, characterized by a unique identifier,
/// dimension, and a formula for its boundary.
/// The identifier type must be convertible to an integer, since it is used
/// for indexing arrays of certain types.
template <class IdT, class DimT, class CoefT>
class tAlgCell
{
public:
        /// The type of a cell identifier.
        typedef IdT IdType;

        /// The type of integer used to store the dimension of the cell.
        typedef DimT DimType;

        /// The type of coefficients in the chain.
        typedef CoefT CoefType;

        /// The default constructor of an empty cell (id 0).
        tAlgCell ();

        /// The constructor of a cell with a given identifier.
        /// Note that its dimension (if >= 0) and boundary (if nonzero)
        /// must be already set earlier (for this id)
        /// or must be set later (using methods available for this cell).
        explicit tAlgCell (const IdT &identifier);

        /// The copy constructor.
        tAlgCell (const tAlgCell<IdT,DimT,CoefT> &c);

        /// The constructor of the n-th boundary cell.
        tAlgCell (const tAlgCell<IdT,DimT,CoefT> &c, int_t n);

        /// The assignment operator.
        tAlgCell<IdT,DimT,CoefT> &operator =
                (const tAlgCell<IdT,DimT,CoefT> &s);

        /// The destructor.
        ~tAlgCell ();

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

        /// Returns the identifier of the cell.
        const IdT &getId () const;

        /// Returns the length of the boundary of the elementary cube.
        int_t boundaryLength () const;

        /// Returns the n-th coefficient in the boundary of the cube.
        const CoefT &boundaryCoef (int_t n) const;

        /// The equality operator.
        bool operator == (const tAlgCell<IdT,DimT,CoefT> &s) const;

        /// Swaps the data with another cell.
        void swap (tAlgCell<IdT,DimT,CoefT> &s);

        /// Returns the next available identifier to be used for cells.
        static IdT newId ();

        /// Sets the dimension of the cell with the given identifier.
        static void setDimension (const IdT &identifier,
                const DimT &dimension);

        /// Sets the boundary of the cell with the given identifier.
        static void setBoundary (const IdT &identifier,
                const tChain<tAlgCell<IdT,DimT,CoefT>,CoefT> &boundary);

        /// Forgets all the boundaries and dimensions of cells and resets
        /// the identifier counter. Note that after this 'reset' all the
        /// cells that exist are not valid anymore.
        static void forget ();

private:
        /// The identifier of the cell.
        IdT id;

        /// The next free identifier for a new cell.
        static IdT maxUsedId;

        /// A global array of dimensions of the cells.
        static chomp::homology::multitable<DimT> dimensions;

        /// A global variable remembering if the dimension of cell 0
        /// was already set to -1.
        static bool dim0initialized;

        /// A global array of boundaries of the cells.
        static chomp::homology::multitable
                <tChain<tAlgCell<IdT,DimT,CoefT>,CoefT> > boundaries;

}; /* class tAlgCell */

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

template <class IdT, class DimT, class CoefT>
IdT tAlgCell<IdT,DimT,CoefT>::maxUsedId (0);

template <class IdT, class DimT, class CoefT>
chomp::homology::multitable<DimT> tAlgCell<IdT,DimT,CoefT>::dimensions (256);

template <class IdT, class DimT, class CoefT>
bool tAlgCell<IdT,DimT,CoefT>::dim0initialized (false);

template <class IdT, class DimT, class CoefT>
chomp::homology::multitable<tChain<tAlgCell<IdT,DimT,CoefT>,CoefT> >
        tAlgCell<IdT,DimT,CoefT>::boundaries (256);

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

template <class IdT, class DimT, class CoefT>
inline tAlgCell<IdT,DimT,CoefT>::tAlgCell (): id (0)
{
        return;
} /* tAlgCell::tAlgCell */

template <class IdT, class DimT, class CoefT>
inline tAlgCell<IdT,DimT,CoefT>::tAlgCell (const IdT &identifier):
        id (identifier)
{
        return;
} /* tAlgCell::tAlgCell */

template <class IdT, class DimT, class CoefT>
inline tAlgCell<IdT,DimT,CoefT>::tAlgCell
        (const tAlgCell<IdT,DimT,CoefT> &c):
        id (c. id)
{
        return;
} /* tAlgCell::tAlgCell */

template <class IdT, class DimT, class CoefT>
inline tAlgCell<IdT,DimT,CoefT>::tAlgCell
        (const tAlgCell<IdT,DimT,CoefT> &c, int_t n):
        id (boundaries [c. id]. getCell (n). id)
{
        return;
} /* tAlgCell::tAlgCell */

template <class IdT, class DimT, class CoefT>
inline tAlgCell<IdT,DimT,CoefT> &tAlgCell<IdT,DimT,CoefT>::operator =
        (const tAlgCell<IdT,DimT,CoefT> &c)
{
        id = c. id;
        return *this;
} /* tAlgCell::operator = */

template <class IdT, class DimT, class CoefT>
inline tAlgCell<IdT,DimT,CoefT>::~tAlgCell ()
{
        return;
} /* tAlgCell::~tAlgCell */

template <class IdT, class DimT, class CoefT>
inline const DimT &tAlgCell<IdT,DimT,CoefT>::dim () const
{
        if (!id && !dim0initialized)
        {
                dimensions [0] = static_cast<DimT> (-1);
                dim0initialized = true;
        }
        return dimensions [id];
} /* tAlgCell::dim */

template <class IdT, class DimT, class CoefT>
inline const IdT &tAlgCell<IdT,DimT,CoefT>::getId () const
{
        return id;
} /* tAlgCell::getId */

template <class IdT, class DimT, class CoefT>
inline int_t tAlgCell<IdT,DimT,CoefT>::boundaryLength () const
{
        return boundaries [id]. size ();
} /* tAlgCell::boundaryLength */

template <class IdT, class DimT, class CoefT>
inline const CoefT &tAlgCell<IdT,DimT,CoefT>::boundaryCoef (int_t n) const
{
        return boundaries [id]. getCoef (n);
} /* tAlgCell::boundaryCoef */

template <class IdT, class DimT, class CoefT>
inline bool tAlgCell<IdT,DimT,CoefT>::operator ==
        (const tAlgCell<IdT,DimT,CoefT> &c) const
{
        return (id == c. id);
} /* tAlgCell::operator == */

template <class IdT, class DimT, class CoefT>
inline void tAlgCell<IdT,DimT,CoefT>::swap (tAlgCell<IdT,DimT,CoefT> &c)
{
        std::swap (id, c. id);
        return;
} /* tAlgCell::swap */

template <class IdT, class DimT, class CoefT>
inline IdT tAlgCell<IdT,DimT,CoefT>::newId ()
{
        return (++ maxUsedId);
} /* tAlgCell::newId */

template <class IdT, class DimT, class CoefT>
inline void tAlgCell<IdT,DimT,CoefT>::setDimension (const IdT &identifier,
        const DimT &dimension)
{
        dimensions [identifier] = dimension;
        return;
} /* tAlgCell::setDimension */

template <class IdT, class DimT, class CoefT>
inline void tAlgCell<IdT,DimT,CoefT>::setBoundary (const IdT &identifier,
        const tChain<tAlgCell<IdT,DimT,CoefT>,CoefT> &boundary)
{
        boundaries [identifier] = boundary;
        return;
} /* tAlgCell::setBoundary */

template <class IdT, class DimT, class CoefT>
inline void tAlgCell<IdT,DimT,CoefT>::forget ()
{
        // reset the identifier numbers
        maxUsedId = 0;

        // forget the dimensions of the cells
        chomp::homology::multitable<DimT> emptyDimensions;
        dimensions = emptyDimensions;

        // forget the information if dimension of cell 0 was initialized
        dim0initialized = false;

        // forget the boundaries of the cells
        chomp::homology::multitable
                <tChain<tAlgCell<IdT,DimT,CoefT>,CoefT> > emptyBoundaries;
        boundaries = emptyBoundaries;

        return;
} /* tAlgCell::setBoundary */

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

/// Generates a hashing key no. 1 for an abstract algebraic cell.
/// This key is to be used in a hashed set.
template <class IdT, class DimT, class CoefT>
inline int_t hashkey1 (const tAlgCell<IdT,DimT,CoefT> &c)
{
        return (static_cast<int_t> (c. getId ()) << 3) ^ 0xA5A5A5;
} /* hashkey1 */

/// Generates a hashing key no. 1 for an abstract algebraic cell.
/// This key is to be used in a hashed set.
template <class IdT, class DimT, class CoefT>
inline int_t hashkey2 (const tAlgCell<IdT,DimT,CoefT> &c)
{
        return (static_cast<int_t> (c. getId ()) << 5) ^ 0x5A5A5A;
} /* hashkey2 */

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

/// Writes an abstract algebraic cell in the text mode to an output stream.
template <class IdT, class DimT, class CoefT>
std::ostream &operator << (std::ostream &out,
        const tAlgCell<IdT,DimT,CoefT> &c)
{
        out << c. getId ();
//      out << '_' << c. dim ();
        return out;
} /* operator << */

/// Reads an elementary cube from the input stream in the text format.
/// Skips all the characters in the input stream until
/// an opening parenthesis is found.
/// Then reads the cartesian product that defines the cube.
/// If no elementary cube is found in the input then the cube
/// is not modified.
template <class IdT, class DimT, class CoefT>
std::istream &operator >> (std::istream &in, tAlgCell<IdT,DimT,CoefT> &c)
{
        // ignore any comments, spaces, tabs and new-line characters
        chomp::homology::ignorecomments (in);

        // get the identifier of the cell
        IdT id (0);
        in >> id;

        // define the cell
        c = tAlgCell<IdT,DimT,CoefT> (id);

        // check for the underscore and read it if present
        if (in. peek () != '_')
                return in;
        in. get ();

        // get the dimension of the cell
        DimT dim (-1);
        in >> dim;

        // set the dimensioin of the cell
        tAlgCell<IdT,DimT,CoefT>::setDimension (id, dim);

        return in;
} /* operator >> */


#endif // _CHAINCON_ALGCELL_H_