morsecache.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file morsecache.h
///
/// Caching Morse decompositions using compressed binary files.
/// This file contains the definition of two functions,
/// one for saving and another one for retrieving a Morse decomposition
/// together with auxiliary data (as computed by computeMorseDecomposition).
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////
 
// Copyright (C) 1997-2014 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 on July 7, 2014. Last revision: July 8, 2014.
 
 
#ifndef _CMGRAPHS_MORSECACHE_H_
#define _CMGRAPHS_MORSECACHE_H_
 
 
// include some standard C++ header files
#include <algorithm>
#include <new>
#include <string>
#include <sstream>
 
// include selected header files from the CHomP library
#include "chomp/system/textfile.h"
#include "chomp/cubes/pointset.h"
#include "chomp/struct/digraph.h"
#include "chomp/struct/multitab.h"
#include "chomp/struct/hashsets.h"
#include "chomp/system/timeused.h"
 
// include local header files
#include "config.h"
#include "typedefs.h"
#include "conindex.h"
#include "morsedec.h"
#include "typedyns.h"
#include "utils.h"
#include "bytecompr.h"
#include "byteutil.h"
 
 
 
 
// ----------------------------------------------------------------
// TODO: Save and retrieve connections in the Morse decompositions,
// and Conley indices, too!
// ----------------------------------------------------------------
 
 
 
// --------------------------------------------------
// ---------- saving a Morse decomposition ----------
// --------------------------------------------------
 
/// Saves a Morse decomposition to a binary file.
/// Throws an error message in case of failure.
inline void saveMorseDecCache (const char *fileName,
        const theMorseDecompositionType &morseDec,
        const std::vector<int> &wrongIndices,
        const std::vector<int> &skippedIndices,
        const std::vector<int> &attractors)
{
        std::ofstream outStream (fileName, std::ios::out | std::ios::binary);
        ByteCompressor out (outStream);
        int nSets (morseDec. count ());
        out << nSets;
        for (int n = 0; n < nSets; ++ n)
                out << morseDec [n];
        for (int n = 0; n < nSets; ++ n)
        {
                std::ostringstream str;
                str << morseDec. index (n);
                out << str. str ();
        }
        for (int n = 0; n < nSets; ++ n)
        {
                for (int m = 0; m < nSets; ++ m)
                {
                        out << (morseDec. connected (n, m) ? '\1' : '\0');
                }
        }
        out << wrongIndices;
        out << skippedIndices;
        out << attractors;
        out << static_cast<int> (controlNumber);
        out. close ();
        return;
} /* saveMorseDecCache */
 
 
// --------------------------------------------------
// --------- loading a Morse decomposition ----------
// --------------------------------------------------
 
/// Loads a Morse decomposition from a binary file.
/// Throws an error message in case of failure.
inline void loadMorseDecCache (const char *fileName,
        theMorseDecompositionType &morseDec,
        std::vector<int> &wrongIndices,
        std::vector<int> &skippedIndices,
        std::vector<int> &attractors)
{
        std::ifstream inStream (fileName, std::ios::in | std::ios::binary);
        ByteDecompressor in (inStream);
        int nSets (0);
        in >> nSets;
        morseDec. setnumber (nSets);
        for (int n = 0; n < nSets; ++ n)
                in >> morseDec [n];
        for (int n = 0; n < nSets; ++ n)
        {
                std::string s;
                in >> s;
                std::istringstream str (s);
                theMorseDecompositionType::IndexType ind;
                str >> ind;
                morseDec. setindex (n, ind);
        }
        for (int n = 0; n < nSets; ++ n)
        {
                for (int m = 0; m < nSets; ++ m)
                {
                        char c;
                        in >> c;
                        if (c)
                                morseDec. addconn (n, m);
                }
        }
        in >> wrongIndices;
        in >> skippedIndices;
        in >> attractors;
        int ctrl (0);
        in >> ctrl;
        if (ctrl != controlNumber)
                throw "Wrong control number while loading cached Morse dec.";
        in. close ();
        return;
} /* loadMorseDecCache */
 
 
#endif // _CMGRAPHS_MORSECACHE_H_