engines.h

Go to the documentation of this file.

// This file copyright (C) 1997-2010 by Pawel Pilarczyk.
//
// This file is part of the "chomp" program. It 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 2 of the License, or (at your option) any later version.
//
// This library 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, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// Started in March 2006. Last revision: April 14, 2006.


#ifndef _CAPD_HOMENGIN_ENGINES_H_ 
#define _CAPD_HOMENGIN_ENGINES_H_ 

#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
#include "chomp/system/timeused.h"
#include "chomp/system/arg.h"
#include "chomp/homology/homology.h"
#include "chomp/homology/homtools.h"

#include "capd/homologicalAlgebra/embeddingDim.h"
#include "capd/chom/dim.hpp"
#include "capd/auxil/ofstreamcout.h"
extern ofstreamcout fcout;

#include "capd/homengin/cubfiles.h"
#include "capd/homengin/algstruct.h"

#include <cstdlib>
#include <ctime>
#include <cstring>
#include <new>
#include <exception>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <vector>
#include <sstream>


namespace chomp {

namespace homengin {

// --------------------------------------------------
// ---------------- ABSTRACT ENGINE -----------------
// --------------------------------------------------

class engine
{
public:
        typedef std::vector<const engine *> enginelist;

        static enginelist engines;

protected:
        engine ()
        {
                engines. push_back (this);
                return;
        }

        virtual ~engine ()
        {
                enginelist::iterator it = std::find (engines. begin (),
                        engines. end (), this);
                if (it != engines. end ())
                        engines. erase (it);
                return;
        }

public:
        virtual int speed () const
        {
                return 0;
        }

        virtual bool dimsupported (int dim) const
        {
                return false;
        }

        virtual int memory (const cubfile &X) const
        {
                return 0;
        }

        virtual bool relative () const
        {
                return false;
        }

        virtual bool elementary () const
        {
                return false;
        }

        virtual bool spacewrapping () const
        {
                return false;
        }

        virtual void homology (const cubfile &x,
                algstruct<chomp::homology::integer> &h) const
        {
                throw "Homology computation not supported.";
        }

        virtual void homology (const cubfile &x, const cubfile &y,
                algstruct<chomp::homology::integer> &h) const
        {
                throw "Relative homology computation not supported.";
        }

        virtual const char *name () const
        {
                return "";
        }

        virtual std::ostream &describe (std::ostream &out) const
        {
                out << "This is an unknown homology engine.\n";
                return out;
        }

        static std::ostream &showlist (std::ostream &out,
                const engine::enginelist &elist = engine::engines);

        static const engine *find (const cubfile *X, const cubfile *Y,
                const engine::enginelist &elist = engine::engines);

        static const engine *find (const cubfile *X,
                const engine::enginelist &elist = engine::engines)
        {
                return find (X, 0, elist);
        }

        static const engine *find (const char *name,
                const engine::enginelist &elist = engine::engines);

private:
}; /* class engine */


// --------------------------------------------------
// ------------------- PP ENGINE --------------------
// --------------------------------------------------

class PPengine: public engine
{
protected:
        PPengine ()
        {
                return;
        }

        ~PPengine ()
        {
                return;
        }

public:
        int speed () const
        {
                return 100;
        }

        bool dimsupported (int dim) const
        {
                return (dim > 0) && (dim <= chomp::homology::Cube::MaxDim);
        }

        int memory (const cubfile &X) const;

        bool relative () const
        {
                return true;
        }

        bool elementary () const
        {
                return true;
        }

        bool spacewrapping () const
        {
                return true;
        }

        void homology (const cubfile &x,
                algstruct<chomp::homology::integer> &h) const;

        void homology (const cubfile &x, const cubfile &y,
                algstruct<chomp::homology::integer> &h) const;

        const char *name () const
        {
                return "PP";
        }

        std::ostream &describe (std::ostream &out) const;

        static PPengine eng;

}; /* class PPengine */


// --------------------------------------------------
// ------------------- BK ENGINE --------------------
// --------------------------------------------------

class BKengine: public engine
{
protected:
        BKengine (): useLookupTable (false)
        {
                return;
        }

        ~BKengine ()
        {
                return;
        }

public:
        int speed () const
        {
                return 250;
        }

        bool dimsupported (int dim) const
        {
                return (dim == DIM);
        }

        int memory (const cubfile &X) const;

        bool relative () const
        {
                return false;
        }

        bool elementary () const
        {
                return false;
        }

        bool spacewrapping () const
        {
                return false;
        }

        void homology (const cubfile &x,
                algstruct<chomp::homology::integer> &h) const;

        void homology (const cubfile &x, const cubfile &y,
                algstruct<chomp::homology::integer> &h) const
        {
                throw "The BK engine cannot compute relative homology.";
        }

        const char *name () const
        {
                return "BK";
        }

        std::ostream &describe (std::ostream &out) const;

        static BKengine eng;

protected:
        bool useLookupTable;

}; /* class BKengine */


// --------------------------------------------------
// ------------------ BK_LT ENGINE ------------------
// --------------------------------------------------

class BK_LTengine: public BKengine
{
protected:
        BK_LTengine ()
        {
                useLookupTable = true;
                return;
        }

        ~BK_LTengine ()
        {
                return;
        }

public:
        int speed () const
        {
                return 260;
        }

        const char *name () const
        {
                return "BK_LT";
        }

        std::ostream &describe (std::ostream &out) const;

        static BK_LTengine eng;

}; /* class BK_LTengine */


// --------------------------------------------------
// -------------- A GENERAL MM ENGINE ---------------
// --------------------------------------------------

class MMengine: public engine
{
protected:
        MMengine ()
        {
                return;
        }

        ~MMengine ()
        {
                return;
        }

public:
        virtual int speed () const = 0;

        bool dimsupported (int dim) const
        {
                return (dim == embeddingDim);
        }

        int memory (const cubfile &X) const;

        bool relative () const
        {
                return false;
        }

        bool elementary () const
        {
                return false;
        }

        bool spacewrapping () const
        {
                return false;
        }

        virtual void homology (const cubfile &x,
                algstruct<chomp::homology::integer> &h) const = 0;

        void homology (const cubfile &x, const cubfile &y,
                algstruct<chomp::homology::integer> &h) const
        {
                throw "The MM* engines do not support relative homology.";
        }

        virtual const char *name () const = 0;

        virtual std::ostream &describe (std::ostream &out) const = 0;

protected:
}; /* class MMengine */


// --------------------------------------------------
// ------------------ MM_CR ENGINE ------------------
// --------------------------------------------------

class MM_CRengine: public MMengine
{
protected:
        MM_CRengine ()
        {
                return;
        }

        ~MM_CRengine ()
        {
                return;
        }

public:
        int speed () const
        {
                return 5000;
        }

        bool dimsupported (int dim) const
        {
                return ((dim == embeddingDim) || ((dim >= 2) && (dim <= 4)));
        }

        void homology (const cubfile &x,
                algstruct<chomp::homology::integer> &h) const;

        const char *name () const
        {
                return "MM_CR";
        }

        std::ostream &describe (std::ostream &out) const;

        static MM_CRengine eng;

}; /* class MM_CRengine */


// --------------------------------------------------
// ------------------ MM_AR ENGINE ------------------
// --------------------------------------------------

class MM_ARengine: public MMengine
{
protected:
        MM_ARengine ()
        {
                return;
        }

        ~MM_ARengine ()
        {
                return;
        }

public:
        int speed () const
        {
                return 70;
        }

        bool dimsupported (int dim) const
        {
                return ((dim == embeddingDim) || ((dim >= 2) && (dim <= 4)));
        }

        void homology (const cubfile &x,
                algstruct<chomp::homology::integer> &h) const;

        const char *name () const
        {
                return "MM_AR";
        }

        std::ostream &describe (std::ostream &out) const;

        static MM_ARengine eng;

}; /* class MM_ARengine */


// --------------------------------------------------
// ----------------- MM_ASLT ENGINE -----------------
// --------------------------------------------------

class MM_ASLTengine: public MMengine
{
protected:
        MM_ASLTengine ()
        {
                return;
        }

        ~MM_ASLTengine ()
        {
                return;
        }

public:
        int speed () const
        {
                return 1000;
        }

        void homology (const cubfile &x,
                algstruct<chomp::homology::integer> &h) const;

        const char *name () const
        {
                return "MM_ASLT";
        }

        std::ostream &describe (std::ostream &out) const;

        static MM_ASLTengine eng;

}; /* class MM_ASLTengine */


} // namespace homengin
} // namespace chomp

#endif // _CAPD_HOMENGIN_ENGINES_H_