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-2008 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 2 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, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// 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 "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];
        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 >> */


// --------------------------------------------------
// ------------- vector of any objects --------------
// --------------------------------------------------

/// Writes a standard vector of any objects to a MultiWork data structure.
template<class AnyType>
inline chomp::multiwork::mwData &operator << (chomp::multiwork::mwData &data,
        const std::vector<AnyType> &vect)
{
        unsigned int size = vect. size ();
        data << size;
        for (unsigned int i = 0; i < size; ++ i)
                data << vect [i];
        return data;
} /* operator << */

/// Reads a standard vector of any objects from a MultiWork data structure.
template<class AnyType>
inline chomp::multiwork::mwData &operator >> (chomp::multiwork::mwData &data,
        std::vector<AnyType> &vect)
{
        unsigned int size = 0;
        data >> size;
        if (size > 0)
                vect. resize (size);
        for (unsigned int i = 0; i < size; ++ i)
                data >> vect [i];
        return data;
} /* operator >> */


#endif // _CMGRAPHS_DATACONV_H_

---