ez_aw.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// The Alexander-Whitney 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_AW_H_
#define _CHAINCON_EZ_AW_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 relevant local header files
#include "chaincon/combtensor.h"
#include "chaincon/tensor.h"


// --------------------------------------------------
// ------------------ AW operator -------------------
// --------------------------------------------------

/// Computes the compositions of face operators on the given simplicial cell
/// to get the appropriate cells for the AW operator.
template <class ArrayT, class SimCellT>
inline void AW_cells (ArrayT &sb, const SimCellT &s, bool left)
{
        if (left)
        {
                sb [s. dim ()] = s;
                for (int i = s. dim () - 1; i >= 0; -- i)
                        sb [i] = SimCellT (sb [i + 1], i + 1);
        }
        else
        {
                sb [0] = s;
                for (int i = 0; i <= s. dim (); ++ i)
                {
                        sb [i] = s;
                        for (int j = i - 1; j >= 0; -- j)
                                sb [i] = SimCellT (sb [i], j);
                }
        }
        return;
} /* AW_cells */

/// Computes the Alexander-Whitney operator on a product of simplicial cells.
/// Combinatorial version (coefficients in Z_2).
template <class SimCellT>
inline void EZ_AW (const SimCellT &s1, const SimCellT &s2,
        tCombTensor<SimCellT,SimCellT> &t)
{
        int dim = s1. dim ();
        if (dim != s2. dim ())
                throw "Different dimensions in the AW operator.";

        std::vector<SimCellT> s1b (dim + 1);
        AW_cells (s1b, s1, true);
        std::vector<SimCellT> s2b (dim + 1);
        AW_cells (s2b, s2, false);

        for (int n = 0; n <= dim; ++ n)
        {
                if (!s1b [n]. degenerate () && !s2b [n]. degenerate ())
                        t. add (s1b [n], s2b [n]);
        }

        return;
} /* EZ_AW */

/// Computes the Alexander-Whitney operator on a product of simplicial cells.
template <class SimCellT, class CoefT>
inline void EZ_AW (const SimCellT &s1, const SimCellT &s2,
        tTensor<SimCellT,SimCellT,CoefT> &t)
{
        int dim = s1. dim ();
        if (dim != s2. dim ())
                throw "Different dimensions in the AW operator.";

        std::vector<SimCellT> s1b (dim + 1);
        AW_cells (s1b, s1, true);
        std::vector<SimCellT> s2b (dim + 1);
        AW_cells (s2b, s2, false);

        CoefT coef (1);
        for (int n = 0; n <= dim; ++ n)
        {
                if (!s1b [n]. degenerate () && !s2b [n]. degenerate ())
                        t. add (s1b [n], s2b [n], coef);
        }

        return;
} /* EZ_AW */

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

/// Computes the Alexander-Whitney operator on a product of simplicial cells.
/// Combinatorial version (coefficients in Z_2).
template <class ProdCellT>
inline void EZ_AW (const ProdCellT &s,
        tCombTensor<ProdCellT,ProdCellT> &t)
{
        EZ_AW (s. getLeft (), s. getRight (), t);

        return;
} /* EZ_AW */

/// Computes the Alexander-Whitney operator on a product of simplicial cells.
template <class SimCellT, class ProdCellT, class CoefT>
inline void EZ_AW (const ProdCellT &s,
        tTensor<SimCellT,SimCellT,CoefT> &t)
{
        EZ_AW (s. getLeft (), s. getRight (), t);

        return;
} /* EZ_AW */

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

/// Computes the Alexander-Whitney operator on a chain of products
/// of simplicial cells.
/// Combinatorial version (coefficients in Z_2).
template <class SimCellT, class ProdCellT>
inline void EZ_AW (const tCombChain<ProdCellT> &s,
        tCombTensor<SimCellT,SimCellT> &t)
{
        for (int_t n = 0; n < s. size (); ++ n)
        {
                tCombTensor<SimCellT,SimCellT> result;
                EZ_AW (s. getCell (n), result);
                t += result;
        }

        return;
} /* EZ_AW */

/// Computes the Alexander-Whitney operator on a chain of products
/// of simplicial cells.
template <class SimCellT, class ProdCellT, class CoefT>
inline void EZ_AW (const tChain<ProdCellT,CoefT> &s,
        tTensor<SimCellT,SimCellT,CoefT> &t)
{
        for (int_t n = 0; n < s. size (); ++ n)
        {
                tTensor<SimCellT,SimCellT,CoefT> result;
                EZ_AW (s. getCell (n), result);
                result *= s. getCoef (n);
                t += result;
        }

        return;
} /* EZ_AW */


#endif // _CHAINCON_EZ_AW_H_