ez_eml.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// The Eilenberg-Mac Lane operator as a component
/// of the Eilenberg-Zilber chain contraction.
///
/////////////////////////////////////////////////////////////////////////////

// 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: December 4, 2014.


#ifndef _CHAINCON_EZ_EML_H_
#define _CHAINCON_EZ_EML_H_


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

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

// include relevant local header files
#include "chaincon/combtensor.h"
#include "chaincon/tensor.h"
#include "chaincon/prodcell.h"
#include "chaincon/shuffles.h"


// --------------------------------------------------
// ------------------ EML operator ------------------
// --------------------------------------------------

/// Computes the Eilenberg-Mac Lane operator on a tensor product
/// of two simplicial cells.
/// Combinatorial version (coefficients in Z_2).
template <class SimCellT, class ProdCellT>
inline void EZ_EML (const SimCellT &s1, const SimCellT &s2,
        tCombChain<ProdCellT> &t)
{
        int p = s1. dim ();
        int q = s2. dim ();
        Shuffles s (p, q);
        std::vector<int> alpha (p);
        std::vector<int> beta (q);
        int sig (0);
        while (1)
        {
                // get the next shuffle
                bool moreAvailable = s. get (alpha, beta, sig);

                // compute the degenerate cells
                SimCellT cell1 (s1);
                for (int i = 0; i < q; ++ i)
                {
                        SimCellT cell1new (cell1, -1 - beta [i]);
                        cell1. swap (cell1new);
                }
                SimCellT cell2 (s2);
                for (int i = 0; i < p; ++ i)
                {
                        SimCellT cell2new (cell2, -1 - alpha [i]);
                        cell2. swap (cell2new);
                }

                // add the product to the result
                ProdCellT prod (cell1, cell2);
                if (!prod. degenerate ())
                        t. add ();

                // finish the work if no more shuffles are available
                if (!moreAvailable)
                        break;
        }

        return;
} /* EZ_EML */

/// Computes the Eilenberg-Mac Lane operator on a tensor product
/// of two simplicial cells.
template <class SimCellT, class ProdCellT, class CoefT>
inline void EZ_EML (const SimCellT &s1, const SimCellT &s2,
        tChain<ProdCellT,CoefT> &t)
{
//      using chomp::homology::sbug;

        int p = s1. dim ();
        int q = s2. dim ();
        Shuffles s (p, q);
        std::vector<int> alpha (p);
        std::vector<int> beta (q);
        int sig (0);
        while (1)
        {
                // get the next shuffle
                bool moreAvailable = s. get (alpha, beta, sig);

                // compute the degenerate cells
                SimCellT cell1 (s1);
                for (int i = 0; i < q; ++ i)
                {
                        SimCellT cell1new (cell1, -1 - beta [i]);
                        cell1. swap (cell1new);
                }
                SimCellT cell2 (s2);
                for (int i = 0; i < p; ++ i)
                {
                        SimCellT cell2new (cell2, -1 - alpha [i]);
                        cell2. swap (cell2new);
                }

                // determine the correct coefficient
                CoefT coef (1);
                if (sig & 1)
                        coef. negate ();

                // add the product to the result
                ProdCellT prod (cell1, cell2);
                if (!prod. degenerate ())
                        t. add (prod, coef);
        //      sbug << "DEBUG EZ_EML: p = " << p <<
        //              ", q = " << q << ": " <<
        //              coef << " * " <<
        //              cell1 << " X " << cell2 << "\n";

                // finish the work if no more shuffles are available
                if (!moreAvailable)
                        break;
        }

        return;
} /* EZ_EML */

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

/// Computes the Eilenberg-Mac Lane operator on a tensor product
/// of two simplicial cells.
/// Combinatorial version (coefficients in Z_2).
template <class SimCellT, class ProdCellT>
inline void EZ_EML (const tCombTensor<SimCellT,SimCellT> &s,
        tCombChain<ProdCellT> &t)
{
        for (int_t n = 0; n < s. size (); ++ n)
        {
                tCombChain<ProdCellT> result;
                EZ_EML (s. left (n), s. right (n), result);
                t += result;
        }

        return;
} /* EZ_EML */

/// Computes the Eilenberg-Mac Lane operator on a tensor product
/// of two simplicial cells.
template <class SimCellT, class ProdCellT, class CoefT>
inline void EZ_EML (const tTensor<SimCellT,SimCellT,CoefT> &s,
        tChain<ProdCellT,CoefT> &t)
{
        for (int_t n = 0; n < s. size (); ++ n)
        {
                tChain<ProdCellT,CoefT> result;
                EZ_EML (s. left (n), s. right (n), result);
                result *= s. coef (n);
                t += result;
        }

        return;
} /* EZ_EML */


#endif // _CHAINCON_EZ_EML_H_