mapparam.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file mapparam.h
///
/// A simple aggregate data structure for map parameters.
///
/// @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 March 25, 2013. Last revision: November 12, 2013.
 
 
#ifndef _CMGRAPHS_MAPPARAM_H_
#define _CMGRAPHS_MAPPARAM_H_
 
 
// include some standard C++ header files
#include <string>
#include <sstream>
#include <vector>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <memory>
#include <utility>
 
// include all the necessary header files from the CHomP library
#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
#include "chomp/struct/autoarray.h"
#include "chomp/multiwork/mwdata.h"
 
 
// --------------------------------------------------
// ------------ map parameters aggregate ------------
// --------------------------------------------------
 
/// A data structure for storing map parameters.
class MapParam
{
public:
        /// The default constructor.
        MapParam ();
 
        /// The destructor.
        ~MapParam ();
 
        /// Defines a data structure based on the given parameters.
        void define (const double *leftParam, const double *rightParam,
                int nParam);
 
        /// Returns the number of parameters.
        size_t size () const;
 
        /// Returns the n-th left bound for the parameters.
        const double &left (size_t n) const;
 
        /// Returns the n-th right bound for the parameters.
        const double &right (size_t n) const;
 
        /// Writes a parameter aggregate data object to an output stream.
        template <class OutputStream>
        OutputStream &write (OutputStream &out) const;
 
        /// Reads a parameter aggregate data object from an input stream.
        template <class InputStream>
        InputStream &read (InputStream &in);
 
private:
        /// An aggregate data container for the parameters.
        std::vector<std::pair<double,double> > param;
 
}; /* class MapParam */
 
// --------------------------------------------------
 
inline MapParam::MapParam ()
{
        return;
} /* MapParam::MapParam */
 
inline MapParam::~MapParam ()
{
        return;
} /* MapParam::~MapParam */
 
inline void MapParam::define (const double *leftParam,
        const double *rightParam, int nParam)
{
        param. resize (nParam);
        for (int i = 0; i < nParam; ++ i)
        {
                param [i]. first = leftParam [i];
                param [i]. second = rightParam [i];
        }
        return;
} /* MapParam::define */
 
inline size_t MapParam::size () const
{
        return param. size ();
} /* MapParam::size */
 
inline const double &MapParam::left (size_t n) const
{
        return param [n]. first;
} /* MapParam::left */
 
inline const double &MapParam::right (size_t n) const
{
        return param [n]. second;
} /* MapParam::right */
 
template <class OutputStream>
inline OutputStream &MapParam::write (OutputStream &out) const
{
        int precision = out. precision ();
        int hiprec = 12;
        out << std::setprecision (hiprec);
        for (size_t n = 0; n < param. size (); ++ n)
        {
                out << (n ? "x[" : "[") << param [n]. first << "," <<
                        param [n]. second << "]";
        }
        out << std::setprecision (precision);
        return out;
} /* MapParam::write */
 
template <class InputStream>
inline InputStream &MapParam::read (InputStream &in)
{
        using chomp::homology::ignorecomments;
 
        param. clear ();
        while (1)
        {
                ignorecomments (in);
                if (in. get () != '[')
                        throw "Can't read parameters: Missing '['.";
                ignorecomments (in);
                std::pair<double,double> x;
                in >> x. first;
                ignorecomments (in);
                if (in. get () != ',')
                        throw "Can't read paramters: Missing comma.";
                ignorecomments (in);
                in >> x. second;
                ignorecomments (in);
                if (in. get () != ']')
                        throw "Can't read parameters: Missing ']'.";
                ignorecomments (in);
                param. push_back (x);
                if (in. peek () != 'x')
                        break;
                in. get ();
        }
        return in;
} /* MapParam::read */
 
// --------------------------------------------------
 
/// Checks if the two collections of parameters are exactly the same.
/// Returns true if yes, false if no.
inline bool operator == (const MapParam &a, const MapParam &b)
{
        size_t size (a. size ());
        if (size != b. size ())
                return false;
        for (size_t i = 0; i < size; ++ i)
        {
                if (a. left (i) != b. left (i))
                        return false;
                if (a. right (i) != b. right (i))
                        return false;
        }
        return true;
} /* operator == */
 
// --------------------------------------------------
 
template <class InputStream>
inline InputStream &operator >> (InputStream &in, MapParam &param)
{
        return param. read (in);
} /* operator >> */
 
template <class OutputStream>
inline OutputStream &operator << (OutputStream &out, const MapParam &param)
{
        return param. write (out);
} /* operator << */
 
// --------------------------------------------------
 
/// Serializes an object with map parameters.
inline chomp::multiwork::mwData &operator << (chomp::multiwork::mwData &data,
        const MapParam &mapParam)
{
        int nParam (mapParam. size ());
        data << nParam;
        for (int i = 0; i < nParam; ++ i)
        {
                data << mapParam. left (i);
                data << mapParam. right (i);
        }
        return data;
} /* operator << */
 
/// Deserializes an object with map parameters.
inline chomp::multiwork::mwData &operator >> (chomp::multiwork::mwData &data,
        MapParam &mapParam)
{
        int nParam (-1);
        data >> nParam;
        if (nParam < 0)
                throw "A negative number of map parameters in mwData.";
        if (!nParam)
        {
                mapParam. define (0, 0, 0);
        }
        else
        {
                chomp::homology::auto_array<double> paramPtr
                        (new double [nParam << 1]);
                double *param (paramPtr. get ());;
                for (int i = 0; i < nParam; ++ i)
                {
                        data >> param [i];
                        data >> param [nParam + i];
                }
                mapParam. define (param, param + nParam, nParam);
        }
        return data;
} /* operator >> */
 
// --------------------------------------------------
 
/// Checks if two aggregate parameter objects are so close to each other
/// that after a small blow-up they intersect.
inline bool intersect (const MapParam &par1, const MapParam &par2)
{
        if (par1. size () != par2. size ())
                return false;
        double margin = 0.00001;
        for (size_t n = 0; n < par1. size (); ++ n)
        {
                double left1 = par1. left (n);
                left1 *= (left1 > 0) ? (1.0 - margin) : (1.0 + margin);
                double right1 = par1. right (n);
                right1 *= (right1 > 0) ? (1.0 + margin) : (1.0 - margin);
                double left2 = par2. left (n);
                left2 *= (left2 > 0) ? (1.0 - margin) : (1.0 + margin);
                double right2 = par2. right (n);
                right2 *= (right2 > 0) ? (1.0 + margin) : (1.0 - margin);
                if ((right1 < left2) || (right2 < left1))
                        return false;
        }
        return true;
} /* intersect */
 
/// Checks if two aggregate parameter objects that intersect
/// actually share interiors in the parameters of non-zero length.
/// Note: It must be first verified that they intersect,
/// because the parameters of zero width are not checked.
inline bool shareInteriors (const MapParam &par1, const MapParam &par2)
{
        if (par1. size () != par2. size ())
                return false;
        double marginFraction = 0.1;
        for (size_t n = 0; n < par1. size (); ++ n)
        {
                double left1 = par1. left (n);
                double right1 = par1. right (n);
                if (left1 == right1)
                        continue;
                double left2 = par2. left (n);
                double right2 = par2. right (n);
                if (left2 == right2)
                        continue;
                double margin1 = marginFraction * (right1 - left1);
                left1 += margin1;
                right1 -= margin1;
                double margin2 = marginFraction * (right2 - left2);
                left2 += margin2;
                right2 -= margin2;
                if ((right1 < left2) || (right2 < left1))
                        return false;
        }
        return true;
} /* shareInteriors */
 
 
#endif // _CMGRAPHS_MAPPARAM_H_