maptight.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file maptight.h
///
/// An abstract tight map type that computes the image of a box
/// in terms of a rectangular set from the CAPD package, as opposed to
/// producing a rectangular bounding box (product of intervals).
/// This file contains the definition of an abstract class
/// of a multi-parameter map for the program "cmgraphs.cpp",
/// derived from the class "MapType".
/// A class which defines a particular map can be derived
/// from the class "MapTight" 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: July 19, 2012.
 
 
#ifndef _CMGRAPHS_MAPTIGHT_H_
#define _CMGRAPHS_MAPTIGHT_H_
 
 
// include local header files
#include "typeintv.h"
#include "typespace.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 MapTight: public MapType
{
public:
        /// The default constructor of an object which describes a map.
        MapTight ();
 
        /// The destructor of an object which describe a map.
        ~MapTight ();
 
        /// Computes an interval bounding box for the image of a given box.
        /// This function should not be used but is provided because of
        /// the interface requirements. A function that produces
        /// a rectangular set should be used instead.
        void compute (const double *xleft, const double *xright,
                double *yleft, double *yright, int dim,
                const spcCoord *coord, int subdiv) const;
 
        /// Computes a rectangular set that is an outer enclosure
        /// of the image of the given 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 IntervalVectorType &x,
                RectSetType &y, int dim,
                const spcCoord *coord, int subdiv) const = 0;
 
private:
        /// The copy constructor should not be used.
        MapTight (const MapTight &);
 
        /// The assignment operator should not be used.
        MapTight &operator = (const MapTight &);
 
}; /* class MapTight */
 
// --------------------------------------------------
 
inline MapTight::MapTight ()
{
        return;
} /* MapTight::MapTight */
 
inline MapTight::~MapTight ()
{
        return;
} /* MapTight::~MapTight */
 
inline MapTight::MapTight (const MapTight &)
{
        return;
} /* MapTight::MapTight */
 
inline MapTight &MapTight::operator = (const MapTight &)
{
        return *this;
} /* MapTight::operator = */
 
inline void MapTight::compute (const double *xleft, const double *xright,
                double *yleft, double *yright, int dim,
                const spcCoord *coord, int subdiv) const
{
        // prepare an interval vector for the box from the domain
        IntervalVectorType x (dim);
        for (int i = 0; i < dim; ++ i)
                x [i] = IntervalType (xleft [i], xright [i]);
 
        // compute the rectangular set that covers the image of this box
        RectSetType y (x, x); // dummy rect2set
        compute (x, y, dim, coord, subdiv);
 
        // enclose the rectangular set in an interval vector
        IntervalVectorType result (y);
 
        // save the coordinates of the result
        for (int i = 0; i < dim; ++ i)
        {
                yleft [i] = result [i]. leftBound ();
                yright [i] = result [i]. rightBound ();
        }
 
        // reset the rounding direction setting of the processor
        resetRounding ();
 
        return;
} /* MapTight::compute */
 
 
#endif // _CMGRAPHS_MAPTIGHT_H_