m_stdmap.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file m_stdmap.h
///
/// The Standard Map.
/// This is the Standard Map which is an example of a surface-preserving
/// map of the torus which is chaotic.
///
/// @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 October 26, 2008. Last revision: October 26, 2008.
 
 
#ifndef _CMGRAPHS_STDMAP_H_
#define _CMGRAPHS_STDMAP_H_
 
 
// include local header files
#include "maptype.h"
#include "typeintv.h"
 
 
// --------------------------------------------------
// ---------------- the Standard Map ----------------
// --------------------------------------------------
 
/// This class defines the Standard Map.
/// This map has only one parameter: 'K'.
class StandardMap: public MapType
{
public:
        /// The default constructor.
        StandardMap ();
 
        /// 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.
        void compute (const double *xleft, const double *xright,
                double *yleft, double *yright, int dim,
                const spcCoord *coord, int subdiv) const;
 
}; /* class StandardMap */
 
// --------------------------------------------------
 
inline StandardMap::StandardMap ()
{
        testIntervals ();
        return;
} /* StandardMap::StandardMap */
 
inline void StandardMap::compute (const double *xleft, const double *xright,
        double *yleft, double *yright, int dim, const spcCoord *, int) const
{
        // use the number "pi" defined in the CAPD package
        const IntervalType Pi (pi);
 
        // determine the value of the parameter K
        const IntervalType K (getLeftParam (0), getRightParam (0));
 
        // determine the input variables
        IntervalType I_n (xleft [0], xright [0]);
        IntervalType Theta_n (xleft [1], xright [1]);
 
        // rescale the input data from [0,2] to [0,2pi] for I
        // and from [-1,1] to [-pi,pi] for theta
        I_n *= Pi;
        Theta_n *= Pi;
 
        // compute the values of the next iteration of the two variables
        IntervalType I_next (I_n + K * sin (Theta_n));
        IntervalType Theta_next (Theta_n + I_next);
 
        // rescale the output back to the intervals [0,2] and [-1,1]
        I_next /= Pi;
        Theta_next /= Pi;
 
        // save the coordinates of the result
        yleft [0] = I_next. leftBound ();
        yright [0] = I_next. rightBound ();
        yleft [1] = Theta_next. leftBound ();
        yright [1] = Theta_next. rightBound ();
 
        // swich the rounding direction to the neutral one
        resetRounding ();
        return;
} /* StandardMap::compute */
 
 
#endif // _CMGRAPHS_STDMAP_H_