simplset.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// A simplicial set.
///
/////////////////////////////////////////////////////////////////////////////

// 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 21, 2013.


#ifndef _CHAINCON_SIMPLSET_H_
#define _CHAINCON_SIMPLSET_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"

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


// --------------------------------------------------
// ----------------- simplicial set -----------------
// --------------------------------------------------

/// A simplicial set.
template <class CellT>
class tSimplSet
{
public:
        /// The type of the vertex.
        typedef CellT CellType;

        /// The type of elements in the filtered complex
        /// perceived as a standard-type aggregate.
        typedef CellT value_type;

        /// The default constructor of an empty set.
        tSimplSet ();

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

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

        /// The destructor.
        ~tSimplSet ();

        /// The equality operator.
        bool operator == (const tSimplSet<CellT> &s) const;

        /// Swaps the data between two simplicial sets.
        void swap (tSimplSet<CellT> &s);

        /// Returns the dimension of the highest-dimensional
        /// non-degenerate cell in the simplicial set, or -1 if none.
        int dim () const;

        /// Adds a cell to the complex. Does not add its boundary cells.
        /// Returns the number of the added cell in the complex.
        int_t add (const CellT &c);

        /// Finds a cell in the complex.
        /// Returns its number or -1 if not found.
        int_t getNumber (const CellT &c) const;

        /// Checks if a cell is in the complex.
        bool check (const CellT &c) const;

        /// Returns the number of cells in the simplicial set.
        int_t size () const;

        /// Returns the information on whether the complex is empty or not.
        bool empty () const;

        /// Returns the given cell in the simplicial set.
        const CellT &operator [] (int_t n) const;

        /// Adds faces of all the cells of the given dimension.
        /// Returns the number of faces added.
        int_t addFaces (int dim);

        /// Adds faces of all the cells in the set.
        /// Returns the number of faces added.
        int_t addFaces ();

        /// Adds degenerate cells for all cells whose dimension falls
        /// within the given range, including minDim,
        /// up to but excluding maxDim.
        /// Also adds degenerate cells for all the added cells,
        /// taking the dimension criterion into consideration.
        /// Returns the number of degenerate cells added.
        int_t addDegenerate (int minDim, int maxDim);

        /// Normalizes the set of cells, that is, removes degenerate cells.
        /// Note that the order and the numbers of cells may change.
        /// Returns the number of degenerate cells removed.
        int_t normalize ();

        /// Adds 1 to the reference counter. If in use, returns the number
        /// that indicates how many references to the object exist.
        int_t addRef ();

        /// Subtracts 1 from the reference counter. If in use, returns the
        /// number that indicates how many references of the object remain.
        int_t delRef ();

private:
        /// The highest dimension of a non-degenerate cell.
        int dimension;

        /// The set of all the cells in the complex.
        chomp::homology::hashedset<CellT> cells;

        /// Reference counter. If in use, keeps track on how many
        /// references to the object exist in the program.
        /// Note that if this value is > 0 then the "normalize"
        /// operation is not permitted, because it may change
        /// the order of cells in the array.
        int_t refCount;

}; /* class tSimplSet */

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

template <class CellT>
inline tSimplSet<CellT>::tSimplSet ():
        dimension (-1), cells (0), refCount (0)
{
        return;
} /* tSimplSet::tSimplSet */

template <class CellT>
inline tSimplSet<CellT>::tSimplSet (const tSimplSet<CellT> &s):
        dimension (s. dimension), cells (s. cells), refCount (0)
{
        return;
} /* tSimplSet::tSimplSet */

template <class CellT>
inline tSimplSet<CellT> &tSimplSet<CellT>::operator =
        (const tSimplSet<CellT> &s)
{
        if (this == &s)
                return *this;
        if (refCount > 0)
        {
                chomp::homology::sbug << "WARNING: Assigning a simplicial "
                        "set to one with " << refCount << " references.\n";
        }
        dimension = s. dimension ();
        cells = s. cells;
        refCount = 0;
        return *this;
} /* tSimplSet::operator = */

template <class CellT>
inline tSimplSet<CellT>::~tSimplSet ()
{
        if (refCount > 0)
        {
                chomp::homology::sbug << "WARNING: A simplicial set "
                        "with " << refCount << " references deleted.\n";
        }
        return;
} /* tSimplSet::~tSimplSet */

template <class CellT>
inline bool tSimplSet<CellT>::operator ==
        (const tSimplSet<CellT> &s) const
{
        return ((this == &s) || (cells == s. cells));
} /* tSimplSet::operator == */

template <class CellT>
inline void tSimplSet<CellT>::swap (tSimplSet<CellT> &s)
{
        std::swap (dimension, s. dimension);
        if ((refCount > 0) || (s. refCount > 0))
        {
                chomp::homology::sbug << "WARNING: Swapping "
                        "simplicial sets with " << refCount << " + " <<
                        s. refCount << " references.\n";
        }
        refCount = 0;
        s. refCount = 0;
        cells. swap (s. cells);
        return;
} /* tSimplSet::swap */

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

template <class CellT>
inline int_t tSimplSet<CellT>::add (const CellT &cell)
{
        int dim = cell. dim ();
        int degenerate = cell. degenerate ();
        if (!degenerate && (dimension < dim))
                dimension = dim;
        return cells. add (cell);
} /* tSimplSet::add */

template <class CellT>
inline int_t tSimplSet<CellT>::getNumber (const CellT &cell) const
{
        return cells. getnumber (cell);
} /* tSimplSet::getNumber */

template <class CellT>
inline bool tSimplSet<CellT>::check (const CellT &cell) const
{
        return (cells. getnumber (cell) >= 0);
} /* tSimplSet::check */

template <class CellT>
inline int_t tSimplSet<CellT>::size () const
{
        return cells. size ();
} /* tSimplSet::size */

template <class CellT>
inline bool tSimplSet<CellT>::empty () const
{
        return cells. empty ();
} /* tSimplSet::empty */

template <class CellT>
inline const CellT &tSimplSet<CellT>::operator [] (int_t n) const
{
        int_t size = cells. size ();
        if ((n < 0) || (n >= size))
                throw "Wrong number of a cell in a simplicial set.";
        return cells [n];
} /* tSimplSet::operator [] */

template <class CellT>
inline int_t tSimplSet<CellT>::addFaces (int dim)
{
        int_t prevSize (cells. size ());
        for (int_t i = 0; i < prevSize; ++ i)
        {
                const CellT &cell (cells [i]);
                if (cell. dim () != dim)
                        continue;
        //      int bLen (cell. boundaryLength ());
                for (int j = 0; j <= dim; ++ j)
                        cells. add (CellT (cell, j));
        }
        return (cells. size () - prevSize);
} /* tSimplSet::addFaces */

template <class CellT>
inline int_t tSimplSet<CellT>::addFaces ()
{
        int_t added (0);
        for (int_t dim = dimension; dim > 0; -- dim)
                added += addFaces (dim);
        return added;
} /* tSimplSet::addFaces */

template <class CellT>
inline int_t tSimplSet<CellT>::addDegenerate (int minDim, int maxDim)
{
        int_t prevSize = cells. size ();
        for (int_t cur = 0; cur < cells. size (); ++ cur)
        {
                const CellT &cell (cells [cur]);
                int dim (cell. dim ());
                if ((dim < minDim) || (dim >= maxDim))
                        continue;
                for (int j = 0; j <= dim; ++ j)
                        cells. add (CellT (cell, -1 - j));
        }
        return (cells. size () - prevSize);
} /* tSimplSet::addDegenerate */

template <class CellT>
inline int_t tSimplSet<CellT>::normalize ()
{
        // NOTE: This procedure uses the fact that in a hashedset
        // an element from the end of the array is put at the location
        // of a removed one.
        int_t prevSize = cells. size ();
        for (int_t cur = prevSize - 1; cur >= 0; -- cur)
        {
                if (cells [cur]. degenerate ())
                        cells. removenum (cur);
        }
        return (prevSize - cells. size ());
} /* tSimplSet::normalize */

template <class CellT>
inline int_t tSimplSet<CellT>::addRef ()
{
        ++ refCount;
        return refCount;
} /* tSimplSet::addRef */

template <class CellT>
inline int_t tSimplSet<CellT>::delRef ()
{
        -- refCount;
        if (refCount < 0)
        {
                chomp::homology::sbug << "WARNING: Negative number "
                        "of references (" << refCount << ") to a "
                        "simplicial set encountered.\n";
        }
        return refCount;
} /* tSimplSet::delRef */

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

/// Writes a simplicial set to an output stream using operator << for cells.
template <class CellT>
std::ostream &operator << (std::ostream &out, const tSimplSet<CellT> &s)
{
        int_t size = s. size ();
        for (int_t i = 0; i < size; ++ i)
        {
                out << s [i] << "\n";
        }
        return out;
} /* operator << */

/// Reads a simplicial set from an input stream using oeprator >> for cells.
template <class CellT>
std::istream &operator >> (std::istream &in, tSimplSet<CellT> &s)
{
        chomp::homology::ignorecomments (in);
        while (!in. eof ())
        {
                CellT c;
                in >> c;
                chomp::homology::ignorecomments (in);
                if (c. dim () < 0)
                        break;
                s. add (c);
        }
        return in;
} /* operator >> */


#endif // _CHAINCON_SIMPLSET_H_