cubisets.h

Go to the documentation of this file.

 
 
 
// Copyright (C) 1997-2020 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 <https://www.gnu.org/licenses/>.
 
// Started in January 2002. Last revision: February 2, 2018.
 
 
#ifndef _CHOMP_HOMOLOGY_CUBISETS_H_
#define _CHOMP_HOMOLOGY_CUBISETS_H_
 
#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
#include "chomp/cubes/pointset.h"
#include "chomp/struct/hashsets.h"
#include "chomp/struct/setunion.h"
#include "chomp/homology/cubacycl.h"
#include "chomp/homology/cubired0.h"
#include "chomp/homology/cubired1.h"
#include "chomp/homology/cubired2.h"
 
#include <iostream>
#include <fstream>
#include <cstdlib>
 
namespace chomp {
namespace homology {
 
// the choice of the reduction algorithms
#if defined (_REDUCTION0_)
using namespace reduction0;
#elsif defined (_REDUCTION1_)
using namespace reduction1;
#elsif defined (_REDUCTION2_)
using namespace reduction2;
#else
// the default choice
using namespace reduction1;
#endif
 
 
// --------------------------------------------------
// ------------------ reduce cubes ------------------
// --------------------------------------------------
 
template <class tCube>
inline int_t cubreducequiet (hashedset<tCube> &cset, hashedset<tCube> &other,
        mvmap<tCube,tCube> &cubmap, const hashedset<tCube> &keep,
        bool quiet = true)
{
        const MapRemainsAcyclic<tCube> mapRemainsAcyclic (cubmap);
        hashedset<tCube> emptyset;
        return cubreducequiet (emptyset, cset, other, keep,
                mapRemainsAcyclic, quiet);
} /* cubreducequiet */
 
template <class tCube>
inline int_t cubreduce (hashedset<tCube> &cset, hashedset<tCube> &other,
        mvmap<tCube,tCube> &cubmap, const hashedset<tCube> &keep)
{
        return cubreducequiet (cset, other, cubmap, keep, false);
} /* cubreduce */
 
template <class tCube>
inline int_t cubreducequiet (hashedset<tCube> &cset, hashedset<tCube> &other,
        const hashedset<tCube> &keep, bool quiet = true)
{
        mvmap<tCube,tCube> emptymap;
        const MapRemainsAcyclic<tCube> mapRemainsAcyclic (emptymap);
        hashedset<tCube> emptyset;
        return cubreducequiet (emptyset, cset, other, keep,
                mapRemainsAcyclic, quiet);
} /* cubreducequiet */
 
template <class tCube>
inline int_t cubreduce (hashedset<tCube> &cset, hashedset<tCube> &other,
        const hashedset<tCube> &keep)
{
        return cubreducequiet (cset, other, keep, false);
} /* cubreduce */
 
template <class tCube>
int_t cubreducequiet (const hashedset<tCube> &maincset,
        hashedset<tCube> &cset, bool quiet = true)
{
        mvmap<tCube,tCube> emptymap;
        const MapRemainsAcyclic<tCube> mapRemainsAcyclic (emptymap);
        hashedset<tCube> emptyset;
        return cubreducequiet (maincset, cset, emptyset, emptyset,
                mapRemainsAcyclic, quiet);
} /* cubreducequiet */
 
template <class tCube>
inline int_t cubreduce (const hashedset<tCube> &maincset,
        hashedset<tCube> &cset)
{
        return cubreducequiet (maincset, cset, false);
} /* cubreduce */
 
 
// --------------------------------------------------
// ------------------ expand cubes ------------------
// --------------------------------------------------
 
template <class tCube>
int_t cubexpand (hashedset<tCube> &cset, hashedset<tCube> &other,
        bool quiet = false)
{
        MapCanExpandDummy<tCube> mapCanExpand;
        return cubexpand (cset, other, mapCanExpand, quiet);
} /* cubexpand */
 
template <class tCube>
inline int_t cubexpand (hashedset<tCube> &cset, hashedset<tCube> &other,
        hashedset<tCube> &imgsrc, hashedset<tCube> &img,
        const mvmap<tCube,tCube> &map, bool indexmap,
        bool checkacyclic, bool quiet = false)
{
        MapCanExpand<tCube> mapCanExpand (map, imgsrc, img,
                indexmap, checkacyclic, quiet);
        return cubexpand (cset, other, mapCanExpand, quiet);
} /* cubexpand */
 
 
} // namespace homology
} // namespace chomp
 
#endif // _CHOMP_HOMOLOGY_CUBISETS_H_