awdiagsim.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// A simplicial version of the Alexander-Whitney diagonal.
///
/////////////////////////////////////////////////////////////////////////////

// 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 2, 2014.


#ifndef _CHAINCON_AWDIAGSIM_H_
#define _CHAINCON_AWDIAGSIM_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/simplex.h"
#include "chaincon/combtensor.h"
#include "chaincon/tensor.h"


// --------------------------------------------------
// ------------------ AW diagonal -------------------
// --------------------------------------------------

/// Computes the Alexander-Whitney diagonal of a simplex.
template <class VertexT, class EmptyT>
inline void AWdiagonal (const tSimplex<VertexT,EmptyT> &s,
        tCombTensor<tSimplex<VertexT,EmptyT>,tSimplex<VertexT,EmptyT> > &t)
{
        typedef tSimplex<VertexT,EmptyT> SimplexType;
        int dim = s. dim ();
        VertexT *left = new VertexT [dim + 1];
        VertexT *right = new VertexT [dim + 1];
        for (int n = 0; n <= dim; ++ n)
        {
                for (int i = 0; i <= n; ++ i)
                        left [i] = s [i];
                for (int i = n; i <= dim; ++ i)
                        right [i - n] = s [i];
                t. add (SimplexType (n, left),
                        SimplexType (dim - n, right));
        }
        delete [] right;
        delete [] left;
        return;
} /* AWdiagonal */

/// Computes the sign in the A-W formula for a simplex
/// (see the paper for details).
inline int AW_kappa (int n, int dim)
{
        // TODO: a more efficient version?
//      int sum = (dim * (dim + 1)) / 2 - n;
/*      int sum = 0;
        for (int i = 0; i < n; ++ i)
        {
                sum += i;
        }
        for (int i = n + 1; i <= dim; ++ i)
        {
                sum += i;
        }
*/
//      return (sum & 1) ? -1 : 1;
        return 1;
} /* AW_kappa */

/// Computes the Alexander-Whitney diagonal of a simplex.
template <class VertexT, class EmptyT, class CoefT>
inline void AWdiagonal (const tSimplex<VertexT,EmptyT> &s,
        tTensor<tSimplex<VertexT,EmptyT>,
        tSimplex<VertexT,EmptyT>,CoefT> &t)
{
        typedef tSimplex<VertexT,EmptyT> SimplexType;
        int dim = s. dim ();
        VertexT *left = new VertexT [dim + 1];
        VertexT *right = new VertexT [dim + 1];
        for (int n = 0; n <= dim; ++ n)
        {
                for (int i = 0; i <= n; ++ i)
                        left [i] = s [i];
                for (int i = n; i <= dim; ++ i)
                        right [i - n] = s [i];
                CoefT coef (1);
                if (AW_kappa (n, dim) == -1)
                        coef. negate ();
                t. add (SimplexType (n, left),
                        SimplexType (dim - n, right), coef);
        }
        delete [] right;
        delete [] left;
        return;
} /* AWdiagonal */


#endif // _CHAINCON_AWDIAGSIM_H_