dataconv.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file dataconv.h
///
/// Data conversion for sending/receiving.
/// This file contains the definitions of the operators << and >>
/// for encoding some variables to the binary data structure
/// and retrieving them. This binary data structure is used
/// in the communication between the coordinator and workers.
///
/// @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 February 15, 2008. Last revision: February 29, 2008.
 
 
#ifndef _CMGRAPHS_DATACONV_H_
#define _CMGRAPHS_DATACONV_H_
 
 
// include some standard C++ header files
#include <string>
#include <sstream>
 
// include selected header files from the CHomP library
#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
#include "chomp/multiwork/mw.h"
 
// include local header files
#include "config.h"
#include "typedefs.h"
#include "typedyns.h"
#include "utils.h"
#include "eigenval.h"
 
 
// --------------------------------------------------
// ------------------ Conley index ------------------
// --------------------------------------------------
 
/// Writes a Conley index to a MultiWork data structure.
inline chomp::multiwork::mwData &operator << (chomp::multiwork::mwData &data,
        const theConleyIndexType &ind)
{
        std::ostringstream s;
        s << ind;
        data << s. str ();
        return data;
} /* operator << */
 
/// Reads a Conley index from a MultiWork data structure.
inline chomp::multiwork::mwData &operator >> (chomp::multiwork::mwData &data,
        theConleyIndexType &ind)
{
        std::string str;
        data >> str;
        std::istringstream s (str);
        s >> ind;
        return data;
} /* operator >> */
 
 
// --------------------------------------------------
// ------------ Conley index eigenvalues ------------
// --------------------------------------------------
 
/// Writes a set of Conley index eigenvalues to a MultiWork data structure.
inline chomp::multiwork::mwData &operator << (chomp::multiwork::mwData &data,
        const IndexEigenValues &eigenValues)
{
        int maxLevel = eigenValues. maxLevel ();
        data << maxLevel;
        for (int level = 0; level < maxLevel; ++ level)
        {
                const std::vector<double> &re = eigenValues. re (level);
                const std::vector<double> &im = eigenValues. im (level);
                unsigned int nValues = re. size ();
                if (nValues != im. size ())
                        throw "Different sizes of Re and Im vectors.";
                data << nValues;
                for (unsigned int i = 0; i < nValues; ++ i)
                        data << re [i] << im [i];
        }
        return data;
} /* operator << */
 
/// Reads a set of Conley index eigenvalues from a MultiWork data structure.
inline chomp::multiwork::mwData &operator >> (chomp::multiwork::mwData &data,
        IndexEigenValues &eigenValues)
{
        int maxLevel = 0;
        data >> maxLevel;
        for (int level = 0; level < maxLevel; ++ level)
        {
                std::vector<double> &reVector = eigenValues. re (level);
                std::vector<double> &imVector = eigenValues. im (level);
                unsigned int nValues = 0;
                data >> nValues;
                for (unsigned int i = 0; i < nValues; ++ i)
                {
                        double re = 0, im = 0;
                        data >> re >> im;
                        reVector. push_back (re);
                        imVector. push_back (im);
                }
        }
        return data;
} /* operator >> */
 
 
// --------------------------------------------------
// ----------------- parameter cube -----------------
// --------------------------------------------------
 
/// Writes a parameter cube to a MultiWork data structure.
inline chomp::multiwork::mwData &operator << (chomp::multiwork::mwData &data,
        const parCube &q)
{
        int dim = q. dim ();
        data << dim;
        parCube::CoordType c [parCube::MaxDim];
        for (int i = 0; i < parCube::MaxDim; ++ i)
                c [i] = 0;
        q. coord (c);
        for (int i = 0; i < dim; ++ i)
                data << static_cast<int> (c [i]);
        return data;
} /* operator << */
 
/// Reads a parameter cube from a MultiWork data structure.
inline chomp::multiwork::mwData &operator >> (chomp::multiwork::mwData &data,
        parCube &q)
{
        int dim = 0;
        data >> dim;
        if (dim != paramDim)
                throw "Wrong cube dimension in mwData.";
        parCube::CoordType c [paramDim];
        for (int i = 0; i < dim; ++ i)
        {
                int number = 0;
                data >> number;
                c [i] = static_cast<parCube::CoordType> (number);
        }
        q = parCube (c, dim);
 
        return data;
} /* operator >> */
 
 
// --------------------------------------------------
// ------------- set of parameter cubes -------------
// --------------------------------------------------
 
/// Writes a set of parameter cubes to a MultiWork data structure.
inline chomp::multiwork::mwData &operator << (chomp::multiwork::mwData &data,
        const parCubes &X)
{
        int size = X. size ();
        data << size;
        for (int i = 0; i < size; ++ i)
                data << X [i];
        return data;
} /* operator << */
 
/// Reads a set of parameter cubes from a MultiWork data structure.
inline chomp::multiwork::mwData &operator >> (chomp::multiwork::mwData &data,
        parCubes &X)
{
        int size = 0;
        data >> size;
        if (size < 0)
                throw "Negative size of a set of cubes in mwData.";
        for (int i = 0; i < size; ++ i)
        {
                parCube q;
                data >> q;
                X. add (q);
        }
        return data;
} /* operator >> */
 
 
// --------------------------------------------------
// ---------------- phase space cube ----------------
// --------------------------------------------------
 
/// Writes a phase space cube to a MultiWork data structure.
inline chomp::multiwork::mwData &operator << (chomp::multiwork::mwData &data,
        const spcCube &q)
{
        int dim = q. dim ();
        data << dim;
        spcCube::CoordType c [spcCube::MaxDim];
        q. coord (c);
        for (int i = 0; i < dim; ++ i)
                data << static_cast<int> (c [i]);
        return data;
} /* operator << */
 
/// Reads a phase space cube from a MultiWork data structure.
inline chomp::multiwork::mwData &operator >> (chomp::multiwork::mwData &data,
        spcCube &q)
{
        int dim = 0;
        data >> dim;
        if (dim != spaceDim)
                throw "Wrong cube dimension in mwData.";
        spcCube::CoordType c [paramDim];
        for (int i = 0; i < dim; ++ i)
        {
                int number = 0;
                data >> number;
                c [i] = static_cast<spcCube::CoordType> (number);
        }
        q = spcCube (c, dim);
 
        return data;
} /* operator >> */
 
 
// --------------------------------------------------
// ----------------- directed graph -----------------
// --------------------------------------------------
 
/// Writes a directed graph to a MultiWork data structure.
inline chomp::multiwork::mwData &operator << (chomp::multiwork::mwData &data,
        const chomp::homology::diGraph<> &g)
{
        // write the number of vertices of the directed graph
        int nVert = g. countVertices ();
        data << nVert;
 
        // the numbers of edges emanating from each vertex and their targets
        for (int v = 0; v < nVert; ++ v)
        {
                // write the number of edges emanating vrom this vertex
                int nEdg = g. countEdges (v);
                data << nEdg;
 
                // write the target vertices of the edges
                for (int e = 0; e < nEdg; ++ e)
                {
                        int target = g. getEdge (v, e);
                        data << target;
                }
        }
 
        return data;
} /* operator << */
 
/// Reads a directed graph from a MultiWork data structure.
inline chomp::multiwork::mwData &operator >> (chomp::multiwork::mwData &data,
        chomp::homology::diGraph<> &g)
{
        // determine the number of vertices
        int nVert = -1;
        data >> nVert;
        if (nVert < 0)
                throw "Negative number of vertices decoded from mwData.";
 
        // read the numbers of edges emanating from each vertex
        // and add their targets
        for (int v = 0; v < nVert; ++ v)
        {
                // add the vertex to the graph
                g. addVertex ();
 
                // read the number of edges emanating from this vertex
                int nEdg = -1;
                data >> nEdg;
 
                // read the target vertices and add them to the graph
                for (int e = 0; e < nEdg; ++ e)
                {
                        int target = -1;
                        data >> target;
                        if ((target < 0) || (target >= nVert))
                                throw "Wrong vertex number found in mwData.";
                        g. addEdge (target);
                }
        }
 
        return data;
} /* operator >> */
 
 
#endif // _CMGRAPHS_DATACONV_H_