cellnames.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// A class for naming cells for nice text data output.
///
/////////////////////////////////////////////////////////////////////////////

// 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: January 10, 2013.


#ifndef _CHAINCON_CELLNAMES_H_
#define _CHAINCON_CELLNAMES_H_


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

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

// include relevant local header files
#include "chaincon/stringhash.h"
#include "chaincon/combchain.h"
#include "chaincon/chain.h"
#include "chaincon/combtensor.h"
#include "chaincon/tensor.h"
#include "chaincon/comblinmap.h"
#include "chaincon/linmap.h"


// --------------------------------------------------
// ------------------- cell names -------------------
// --------------------------------------------------

/// A class whose instances can be used to generate names of cells
/// with subsequent numbers, in each dimension separately.
template <class CellT>
class tCellNames
{
public:
        /// The type of a cell identifier.
        typedef CellT CellType;

        /// The type of the name of a cell.
        typedef std::string NameType;

        /// The default constructor of an empty object.
        tCellNames ();

        /// The copy constructor.
        tCellNames (const tCellNames<CellT> &c);

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

        /// The destructor.
        ~tCellNames ();

        /// Sets the prefix for cell names. If the prefix is nonempty
        /// then the cell names are formed from this perfix
        /// with dimension indicator and a subsequent number.
        void setPrefix (const std::string &s);

        /// Sets the postfix for cell names. This is a string
        /// that is appended at the end of every cell name.
        void setPostfix (const std::string &s);

        /// Returns the name of the given cell.
        std::string operator () (const CellT &c);

        /// Returns the smallest strict upper bound for the dimensions
        /// of named cells.
        int maxDim () const;

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

        /// Swaps the data with another object.
        void swap (tCellNames<CellT> &s);

private:
        /// An array of sets of cells whose names have been requested.
        chomp::homology::multitable<chomp::homology::hashedset<CellT> >
                cells;

        /// A prefix for cell names (use none for alphabetic names).
        std::string prefix;

        /// A postfix for cell names.
        std::string postfix;

        /// The number of sets of encountered cells,
        /// indexed by their dimension.
        /// In other words, this is the minimal strict upper bound
        /// for the dimensions of cells.
        int nSets;

}; /* class tCellNames */

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

template <class CellT>
inline tCellNames<CellT>::tCellNames (): nSets (0)
{
        return;
} /* tCellNames::tCellNames */

template <class CellT>
inline tCellNames<CellT>::tCellNames (const tCellNames<CellT> &c):
        cells (c. cells), prefix (c. prefix), postfix (c. postfix),
        nSets (c. nSets)
{
        return;
} /* tCellNames::tCellNames */

template <class CellT>
inline tCellNames<CellT> &tCellNames<CellT>::operator =
        (const tCellNames<CellT> &c)
{
        cells = c. cells;
        prefix = c. prefix;
        postfix = c. postfix;
        nSets = c. nSets;
        return *this;
} /* tCellNames::operator = */

template <class CellT>
inline tCellNames<CellT>::~tCellNames ()
{
        return;
} /* tCellNames::~tCellNames */

template <class CellT>
inline void tCellNames<CellT>::setPrefix (const std::string &s)
{
        prefix = s;
        return;
} /* tCellNames::setPrefix */

template <class CellT>
inline void tCellNames<CellT>::setPostfix (const std::string &s)
{
        postfix = s;
        return;
} /* tCellNames::setPostfix */

template <class CellT>
inline int tCellNames<CellT>::maxDim () const
{
        return nSets;
} /* tCellNames::maxDim */

template <class CellT>
inline std::string tCellNames<CellT>::operator () (const CellT &c)
{
        // determine the dimension of the cell and update the number of sets
        int dim = c. dim ();
        if (dim >= nSets)
                nSets = dim + 1;

        // add the cell to the hashed set if necessary and get its number
        int_t n = cells [dim]. add (c) + 1;

        // generate the cell name and return it
        std::ostringstream s;
        if (prefix. empty ())
        {
                if (dim < 26)
                {
                        s << static_cast<char> ('a' + dim);
                }
                else if (dim < 26 * 26)
                {
                        s << static_cast<char> ('a' + dim / 26 - 1);
                        s << static_cast<char> ('a' + dim % 26);
                }
                else
                {
                        throw "Dimension too high for a cell name.";
                }
                s << n;
        }
        else
        {
                s << prefix << "^" << dim << "_" << n;
        }
        s << postfix;
        return s. str ();
} /* tCellNames::operator () */

template <class CellT>
inline bool tCellNames<CellT>::operator == (const tCellNames<CellT> &s) const
{
        return ((cells == cells) && (prefix == prefix) &&
                (postfix == postfix));
} /* tCellNames::operator == */

template <class CellT>
inline void tCellNames<CellT>::swap (tCellNames<CellT> &c)
{
        cells. swap (c. cells);
        prefix. swap (c. prefix);
        postfix. swap (c. postfix);
        std::swap (nSets, c. nSets);
        return;
} /* tCellNames::swap */


// --------------------------------------------------
// ------------ pass cells through names ------------
// --------------------------------------------------

/// A class for providing the cells as their names.
template <class CellT>
class tCellOwnNames
{
public:
        /// The type of a cell identifier.
        typedef CellT CellType;

        /// The type of the name of a cell.
        typedef CellT NameType;

        /// The default constructor of an empty object.
        tCellOwnNames ();

        // The default copy constructor is OK.
        //tCellOwnNames (const tCellOwnNames<CellT> &c);

        // The default assignment operator is OK.
        //tCellOwnNames<CellT> &operator = (const tCellOwnNames<CellT> &s);

        // The default destructor is OK.
        //~tCellOwnNames ();

        /// Dummy setPrefix procedure.
        void setPrefix (const std::string &s);

        /// Dummy setPostfix procedure.
        void setPostfix (const std::string &s);

        /// Returns the name of the given cell.
        CellT operator () (const CellT &c);

        /// Returns the smallest strict upper bound for the dimensions
        /// of named cells.
        int maxDim () const;

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

        /// Swaps the data with another object.
        void swap (tCellOwnNames<CellT> &s);

private:
        /// The maximal dimension of the encountered cells plus 1.
        int maxCellDim1;

}; /* class tCellOwnNames */

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

template <class CellT>
inline tCellOwnNames<CellT>::tCellOwnNames (): maxCellDim1 (0)
{
        return;
} /* tCellOwnNames::tCellOwnNames */

template <class CellT>
inline void tCellOwnNames<CellT>::setPrefix (const std::string &)
{
        return;
} /* tCellOwnNames::setPrefix */

template <class CellT>
inline void tCellOwnNames<CellT>::setPostfix (const std::string &)
{
        return;
} /* tCellOwnNames::setPostfix */

template <class CellT>
inline int tCellOwnNames<CellT>::maxDim () const
{
        return maxCellDim1;
} /* tCellOwnNames::maxDim */

template <class CellT>
inline CellT tCellOwnNames<CellT>::operator () (const CellT &c)
{
        // determine the dimension of the cell and update the stored max dim
        int dim = c. dim ();
        if (dim >= maxCellDim1)
                maxCellDim1 = dim + 1;

        // return the cell as its own name
        return c;
} /* tCellOwnNames::operator () */

template <class CellT>
inline bool tCellOwnNames<CellT>::operator ==
        (const tCellOwnNames<CellT> &s) const
{
        return maxCellDim1 == s. maxCellDim1;
} /* tCellOwnNames::operator == */

template <class CellT>
inline void tCellOwnNames<CellT>::swap (tCellOwnNames<CellT> &c)
{
        std::swap (maxCellDim1, c. maxCellDim1);
        return;
} /* tCellOwnNames::swap */


// --------------------------------------------------
// ----------- cells to names converters ------------
// --------------------------------------------------

/// Returns the name of a cell according to the given naming object.
template <class CellT, class NamesT>
inline typename NamesT::NameType cells2names (const CellT &in, NamesT &names)
{
        return names (in);
} /* cells2names */

/// Returns a combinatorial chain in which the cells have been replaced
/// with their names, given by the provided naming object.
template <class CellT, class NamesT>
inline tCombChain<typename NamesT::NameType> cells2names
        (const tCombChain<CellT> &in, NamesT &names)
{
        tCombChain<typename NamesT::NameType> out;
        int_t size = in. size ();
        for (int_t i = 0; i < size; ++ i)
                out. add (names (in. getCell (i)));
        return out;
} /* cells2names */

/// Returns a chain in which the cells have been replaced
/// with their names, given by the provided naming object.
template <class CellT, class CoefT, class NamesT>
inline tChain<typename NamesT::NameType,CoefT> cells2names
        (const tChain<CellT,CoefT> &in, NamesT &names)
{
        tChain<typename NamesT::NameType,CoefT> out;
        int_t size = in. size ();
        for (int_t i = 0; i < size; ++ i)
                out. add (names (in. getCell (i)), in. getCoef (i));
        return out;
} /* cells2names */

/// Returns a combinatorial tensor in which the cells have been replaced
/// with their names, given by the provided naming object.
template <class Cell1T, class Cell2T, class Names1T, class Names2T>
inline tCombTensor<typename Names1T::NameType,typename Names2T::NameType>
        cells2names (const tCombTensor<Cell1T,Cell2T> &in,
        Names1T &names1, Names2T &names2)
{
        tCombTensor<typename Names1T::NameType,typename Names2T::NameType>
                out;
        int_t size = in. size ();
        for (int_t i = 0; i < size; ++ i)
                out. add (names1 (in. left (i)), names2 (in. right (i)));
        return out;
} /* cells2names */

/// Returns a tensor in which the cells have been replaced
/// with their names, given by the provided naming object.
template <class Cell1T, class Cell2T, class CoefT,
        class Names1T, class Names2T>
inline tTensor<typename Names1T::NameType,typename Names2T::NameType,CoefT>
        cells2names (const tTensor<Cell1T,Cell2T,CoefT> &in,
        Names1T &names1, Names2T &names2)
{
        tTensor<typename Names1T::NameType,typename Names2T::NameType,CoefT>
                out;
        int_t size = in. size ();
        for (int_t i = 0; i < size; ++ i)
        {
                out. add (names1 (in. left (i)), names2 (in. right (i)),
                        in. coef (i));
        }
        return out;
} /* cells2names */

/// Returns a combinatorial linear map in which the cells have been replaced
/// with their names, given by the provided naming object.
template <class CellDomT, class CellImgT, class NamesDomT, class NamesImgT>
inline tCombLinMap<typename NamesDomT::NameType,typename NamesImgT::NameType>
        cells2names (const tCombLinMap<CellDomT,CellImgT> &in,
        NamesDomT &names1, NamesImgT &names2)
{
        tCombLinMap<typename NamesDomT::NameType,
                typename NamesImgT::NameType> out;
        int_t size = in. size ();
        for (int_t i = 0; i < size; ++ i)
                out. add (names1 (in [i]), cells2names (in (i), names2));
        return out;
} /* cells2names */

/// Returns a linear map in which the cells have been replaced
/// with their names, given by the provided naming object.
template <class CellDomT, class CellImgT, class CoefT,
        class NamesDomT, class NamesImgT>
inline tLinMap<typename NamesDomT::NameType,typename NamesImgT::NameType,
        CoefT> cells2names (const tLinMap<CellDomT,CellImgT,CoefT> &in,
        NamesDomT &names1, NamesImgT &names2)
{
        tLinMap<typename NamesDomT::NameType,typename NamesImgT::NameType,
                CoefT> out;
        int_t size = in. size ();
        for (int_t i = 0; i < size; ++ i)
                out. add (names1 (in [i]), cells2names (in (i), names2));
        return out;
} /* cells2names */


#endif // _CHAINCON_CELLNAMES_H_