maptype.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file maptype.h
///
/// An abstract map type.
/// This file contains the definition of an abstract class
/// of a multi-parameter map for the program "cmgraphs.cpp".
/// Each class which defines a particular map should be derived
/// from the class "MapType" defined in this file,
/// or at least should have the same interface.
///
/// @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 9, 2008. Last revision: September 4, 2014.
 
 
#ifndef _CMGRAPHS_MAPTYPE_H_
#define _CMGRAPHS_MAPTYPE_H_
 
 
// include some standard C++ header files
#include <vector>
#include <string>
 
// include selected header files from the CHomP library
#include "chomp/multiwork/mwdata.h"
#include "chomp/system/textfile.h"
 
// include local header files
#include "typespace.h"
#include "typeintv.h"
 
 
// --------------------------------------------------
// ------------- the abstract map class -------------
// --------------------------------------------------
 
/// This is an abstract class which defines the interface to other classes
/// that describe maps for the use for the program "cmgraphs.cpp".
class MapType
{
public:
        /// The default constructor of an object which describes a map.
        MapType ();
 
        /// The destructor of an object which describe a map.
        virtual ~MapType ();
 
        /// Sets the parameters to the given intervals defined by their
        /// left and right coordinates.
        virtual void setParam (const double *left, const double *right,
                int n);
 
        /// Returns the left value of the given parameter.
        const double &getLeftParam (int n) const;
 
        /// Returns the right value of the given parameter.
        const double &getRightParam (int n) const;
 
        /// Computes the image of a box whose left and right coordinates
        /// are given. Fills in the images with the left and right
        /// coordinates of the image box.
        /// Whenever this information is relevant, the integer coordinates
        /// of the box are provided, as well as the subdivision level
        /// of the full phase space box; otherwise the pointer to the
        /// coordinates is set to 0, and the subdivision level is undefined.
        virtual void compute (const double *xleft, const double *xright,
                double *yleft, double *yright, int dim,
                const spcCoord *coord, int subdiv) const = 0;
 
        /// An interface to the function 'compute' based on intervals.
        void operator () (const IntervalType *x, IntervalType *y,
                int dim, const spcCoord *coord, int subdiv) const;
 
        /// Adjusts parameters if necessary after a successful computation
        /// or after an unsuccessful computation of the graph of the map
        /// at a specific subdivision level.
        /// Returns true iff it is necessary to repeat the computation.
        bool adjust (bool successful, int subdiv);
 
        /// Gets a single line of information on optimization
        /// of the computation of the map, so that it can be used
        /// by maps created for the same and nearby parameter values.
        std::string getOptInfo () const;
 
        /// Uses a prevously saved line of information on optimization
        /// of the computation of the map for the same or nearby
        /// parameter values. The map object may be fed with several lines
        /// and should interprete them to set up its optimization parameters.
        void useOptInfo (const std::string &info);
 
        /// Saves the internal parameters and other data of the map
        /// to the mwData structure.
        void saveInternals (chomp::multiwork::mwData &data) const;
 
        /// Retrieves the internal paramters and other data of the map
        /// from the mwData structure.
        void loadInternals (chomp::multiwork::mwData &data);
 
        /// Returns the time step, which is 1 for a map, or the time t
        /// of integration in case of a time-t map of a flow.
        /// This value may be different at each subdivision depth.
        /// May return an approximate value, especially for flows.
        virtual double getTimeStep (int subdiv) const;
 
        /// Returns the name of the map.
        /// This method should be replaced in derived classes.
        virtual std::string name () const;
 
private:
        /// The left ends of the parameter intervals of the map.
        double *leftParam;
 
        /// The right ends of the parameter intervals of the map.
        double *rightParam;
 
        /// The number of parameters defined.
        int nParam;
 
        /// The copy constructor should not be used.
        MapType (const MapType &);
 
        /// The assignment operator should not be used.
        MapType &operator = (const MapType &);
 
}; /* class MapType */
 
// --------------------------------------------------
 
inline MapType::MapType (): leftParam (0), rightParam (0), nParam (0)
{
        return;
} /* MapType::MapType */
 
inline MapType::~MapType ()
{
        if (leftParam)
                delete [] leftParam;
        if (rightParam)
                delete [] rightParam;
        return;
} /* MapType::~MapType */
 
inline MapType::MapType (const MapType &)
{
        return;
} /* MapType::MapType */
 
inline MapType &MapType::operator = (const MapType &)
{
        return *this;
} /* MapType::operator = */
 
inline void MapType::setParam (const double *left, const double *right,
        int n)
{
        if (n <= 0)
                return;
        if (n != nParam)
        {
                if (nParam)
                {
                        delete [] leftParam;
                        delete [] rightParam;
                }
                leftParam = new double [n];
                rightParam = new double [n];
                nParam = n;
        }
        for (int i = 0; i < nParam; ++ i)
        {
                leftParam [i] = left [i];
                rightParam [i] = right [i];
        }
        return;
} /* MapType::setParam */
 
inline const double &MapType::getLeftParam (int n) const
{
        if (!leftParam || (n >= nParam))
                throw "Requested left parameter not defined.";
        return leftParam [n];
} /* MapType::getLeftParam */
 
inline const double &MapType::getRightParam (int n) const
{
        if (!rightParam || (n >= nParam))
                throw "Requested right parameter not defined.";
        return rightParam [n];
} /* MapType::getRightParam */
 
inline void MapType::operator () (const IntervalType *x, IntervalType *y,
        int dim, const spcCoord *coord, int subdiv) const
{
        double *buffer = new double [4 * dim];
        double *xLeft = buffer;
        double *xRight = buffer + dim;
        for (int i = 0; i < dim; ++ i)
        {
                xLeft [i] = x [i]. leftBound ();
                xRight [i] = x [i]. rightBound ();
        }
        double *yLeft = buffer + 2 * dim;
        double *yRight = buffer + 3 * dim;
        this -> compute (xLeft, xRight, yLeft, yRight, dim, coord, subdiv);
        for (int i = 0; i < dim; ++ i)
                y [i] = IntervalType (yLeft [i], yRight [i]);
        delete [] buffer;
        return;
} /* MapType::operator () */
 
inline bool MapType::adjust (bool, int)
{
        return false;
} /* MapType::adjust */
 
inline std::string MapType::getOptInfo () const
{
        return std::string ();
} /* MapType::getOptInfo */
 
inline void MapType::useOptInfo (const std::string &)
{
        return;
} /* MapType::useOptInfo */
 
inline void MapType::saveInternals (chomp::multiwork::mwData &data) const
{
        // save the number of parameters
        data << nParam;
 
        // save the parameter intervals
        for (int i = 0; i < nParam; ++ i)
        {
                data << leftParam [i];
                data << rightParam [i];
        }
 
        return;
} /* MapType::saveInternals */
 
inline void MapType::loadInternals (chomp::multiwork::mwData &data)
{
        // load the number of parameters
        int n = 0;
        data >> n;
 
        // load the parameter intervals
        double *left = (n > 0) ? new double [n] : 0;
        double *right = (n > 0) ? new double [n] : 0;
        for (int i = 0; i < n; ++ i)
        {
                data >> left [i];
                data >> right [i];
        }
 
        // set the parameters
        this -> setParam (left, right, n);
 
        // forget the temporary arrays with the values of the parameters
        if (left)
                delete [] left;
        if (right)
                delete [] right;
 
        return;
} /* MapType::loadInternals */
 
inline double MapType::getTimeStep (int /*subdiv*/) const
{
        return 1;
} /* MapType::getTimeStep */
 
inline std::string MapType::name () const
{
        return std::string ("map");
} /* MapType::name */
 
#endif // _CMGRAPHS_MAPTYPE_H_