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-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 9, 2008. Last revision: February 9, 2008.


#ifndef _CMGRAPHS_MAPTYPE_H_
#define _CMGRAPHS_MAPTYPE_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.
        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.
        virtual void compute (const double *xleft, const double *xright,
                double *yleft, double *yright, int dim) const = 0;

        /// An interface to the function 'compute' based on intervals.
        template <class IntervalType>
        void operator () (const IntervalType *x, IntervalType *y,
                int dim) 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 */

template <class IntervalType>
inline void MapType::operator () (const IntervalType *x, IntervalType *y,
        int dim) 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);
        for (int i = 0; i < dim; ++ i)
                y [i] = IntervalType (yLeft [i], yRight [i]);
        delete [] buffer;
        return;
} /* MapType::compute */


#endif // _CMGRAPHS_MAPTYPE_H_

---