awdiag1sim.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// A program for the computation of the Alexander-Whitney diagonal
/// for a single simplex.
///
/////////////////////////////////////////////////////////////////////////////

// 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: July 2, 2013.


// 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 "chomp/system/timeused.h"
#include "chomp/system/arg.h"
#include "chomp/struct/hashsets.h"

// include relevant local header files
#include "chaincon/simplex.h"
#include "chaincon/emptycell.h"
#include "chaincon/ringzp.h"
#include "chaincon/awdiagsim.h"
#include "chaincon/combtensor.h"
#include "chaincon/tensor.h"


// --------------------------------------------------
// -------------------- OVERTURE --------------------
// --------------------------------------------------

/// The title of the program and licensing information.
const char *title = "\
Alexander-Whitney diagonal for a single simplex.\n\
Version 0.01 (July 2, 2013). Copyright (C) 1997-2016 by Pawel Pilarczyk.\n\
This is free software. No warranty. Consult 'license.txt' for details.";

/// Brief help information on the program's usage.
const char *helpinfo = "\
This program computes the Alexander-Whitney diagonal for a single cube.\n\
Call with:\n\
-d N - choose the dimension of the cube.\n\
Switches and additional arguments:\n\
-pN - selection of the coefficients: p=0 for Z, p>1 for Z_p (default: 0);\n\
\tnote: one should use p <= 181.\n\
--log filename - save the output to a file (without progress indicators),\n\
--quiet - suppress data output to the screen (whcih can be still logged),\n\
--help - display this brief help information only and exit.\n\
For more information please consult the accompanying documentation\n\
or ask the program's author at http://www.PawelPilarczyk.com/.";


// --------------------------------------------------
// ---------------------- main ----------------------
// --------------------------------------------------

/// The main procedure of the program.
/// Returns: 0 = Ok, -1 = Error, 1 = Help displayed, 2 = Wrong arguments.
int main (int argc, char *argv [])
{
        using namespace chomp::homology;

        // turn on a message that will appear if the program does not finish
        program_time = 0; //"Aborted after";

        // prepare user-configurable data
        int dim = 0;
        int p = 0;

        // analyze the command line
        arguments a;
        arg (a, "d", dim);
        arg (a, "p", p);
        arghelp (a);

        argstreamprepare (a);
        int argresult = a. analyze (argc, argv);
        argstreamset ();

        // show the program's title
        if (argresult >= 0)
                sout << title << '\n';

        // if something was incorrect, show an additional message and exit
        if (argresult < 0)
        {
                sout << "Call with '--help' for help.\n";
                return 2;
        }

        // if help requested, show help information
        if ((argresult > 0) || (dim <= 0))
        {
                sout << helpinfo << '\n';
                return 1;
        }

        // try running the main function and catch an error message if thrown
        try
        {
                // prepare the ring of coefficients
                typedef tZp<short> CoefT;
                CoefT::setp (p);
                p = CoefT::getp ();

                // prepare a single simplex
                typedef tSimplex<int,NoEmptyCell> CellT;
                int *coord = new int [dim + 1];
                for (int i = 0; i <= dim; ++ i)
                        coord [i] = i + 1;
                CellT Q (dim, coord);
                delete [] coord;

                // compute and show the combinatorial AW diagonal
                tCombTensor<CellT,CellT> combDiag;
                AWdiagonal (Q, combDiag);
                sout << "Combinatorial Alexander-Whitney diagonal of " <<
                        Q << ":\n" << combDiag << "\n";

                // compute and show the general AW diagonal
                tTensor<CellT,CellT,CoefT> diag;
                AWdiagonal (Q, diag);
                sout << "Alexander-Whitney diagonal over " <<
                        CoefT::ringsymbol () << " of " <<
                        Q << ":\n" << diag << "\n";

        //      program_time = "Total time used:";
        //      program_time = 1;
                return 0;
        }
        catch (const char *msg)
        {
                sout << "ERROR: " << msg << '\n';
                return -1;
        }
        catch (const std::exception &e)
        {
                sout << "ERROR: " << e. what () << '\n';
                return -1;
        }
        catch (...)
        {
                sout << "ABORT: An unknown error occurred.\n";
                return -1;
        }
} /* main */