savecover.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file savecover.h
///
/// Saving a cover to a file.
/// This file contains the definition of a function that saves a cover
/// to a text file.
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////

// Copyright (C) 1997-2010 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 March 19, 2009. Last revision: March 19, 2009.


#ifndef _FINRESDYN_SAVECOVER_H_
#define _FINRESDYN_SAVECOVER_H_


// include some standard C++ header files
#include <iostream>
#include <fstream>

// include local header files
#include "streams.h"
#include "covboxes.h"


// --------------------------------------------------
// -------------- write double as hex ---------------
// --------------------------------------------------

/// Writes a given unsigned byte in the hexadecimal way.
inline void byte2hex (std::ostream &out, unsigned int byte)
{
        const char symbols [16] = {'0', '1', '2', '3', '4', '5', '6',
                '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        out << symbols [(byte >> 4) & 0x0F] << symbols [byte & 0x0F];
        return;
} /* byte2hex */

/// Writes a double precision floating-point number
/// in the hexadecimal way as bytes.
inline void double2hex (std::ostream &out, const double &x)
{
        // determine the address of the number in the memory
        double number = x;
        const unsigned char *numBytes =
                reinterpret_cast<const unsigned char *> (&number);

        // prepare a number for testing the endianness
        int testByte = 1;

        // in the case of little endian
        if (*reinterpret_cast<const char *> (&testByte) == 1)
        {
                for (int i = sizeof (double) - 1; i >= 0; -- i)
                        byte2hex (out, numBytes [i]);
        }

        // in the case of big endian
        else
        {
                for (unsigned int i = 0; i < sizeof (double); ++ i)
                        byte2hex (out, numBytes [i]);
        }

        return;
} /* double2hex */


// --------------------------------------------------
// ------------------ save a cover ------------------
// --------------------------------------------------

/// Saves the given cover to a text file.
inline void saveCover (const tCoverBoxes<double> &cover,
        const char *filename)
{
        // create a file to save the cover to
        std::ofstream f (filename);
        if (!f)
                throw "Cannot create a file to save the cover to.";

        // determine the dimension of the phase space
        int dim = cover. dim ();

        // save the boxes in the cover
        double *leftBounds = new double [dim];
        double *rightBounds = new double [dim];
        for (int n = 0; n < cover. size (); ++ n)
        {
                // retrieve the bounds of the box
                cover. get (n, leftBounds, rightBounds);

                // write the cartesian product as decimal numbers
                for (int i = 0; i < dim; ++ i)
                {
                        f << (i ? ") x (" : "(") << leftBounds [i] <<
                                "," << rightBounds [i];
                }
                f << ")\n";

                // write the cartesian product using hexadecimal code
                for (int i = 0; i < dim; ++ i)
                {
                        f << (i ? ") x (" : "(");
                        double2hex (f, leftBounds [i]);
                        f << ",";
                        double2hex (f, rightBounds [i]);
                }
                f << ")\n\n";
        }
        delete [] rightBounds;
        delete [] leftBounds;

        return;
} /* saveCover */

/// Throws an exception because of an unknown cover is to be saved.
template <class UnknownCover>
inline void saveCover (const UnknownCover &cover, const char *filename)
{
        throw "Trying to save a cover of unsupported type to a file.";
        return;
} /* saveCover */


#endif // _FINRESDYN_SAVECOVER_H_