engines.h

Go to the documentation of this file.

 
 
 
// This file copyright (C) 1997-2016 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 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 <https://www.gnu.org/licenses/>.
 
// 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_