m_vpol1.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file m_vpol1.h
///
/// A specific time-t map for the Vanderpol ODE.
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////
 
// Copyright (C) 1997-2022 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: April 23, 2022.
 
 
#ifndef _CMGRAPHS_VPOL1_H_
#define _CMGRAPHS_VPOL1_H_
 
 
// include local header files
#include "maptype.h"
#include "typeintv.h"
 
// temporary - for debugging only
#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
 
// --------------------------------------------------
// ----- a time-t map for the Vanderpol system ------
// --------------------------------------------------
 
/// This class defines a time-t map for the Vanderpol system
/// with a fixed (hard-coded) time t.
class MapVanderPol1: public MapType
{
public:
        /// The default constructor.
        MapVanderPol1 ();
 
        /// 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 MapVanderPol1 */
 
// --------------------------------------------------
 
inline MapVanderPol1::MapVanderPol1 ()
{
        testIntervals ();
        return;
} /* MapVanderPol1::MapVanderPol1 */
 
inline void MapVanderPol1::compute (const double *xleft, const double *xright,
        double *yleft, double *yright, int dim, const spcCoord *, int) const
{
        using chomp::homology::sbug;
 
        if (dim != 2)
                throw "Dimension 2 supported only.";
 
        // create intervals that correspond to the point at the n-th iterate
        IntervalType xn = IntervalType (xleft [0], xright [0]);
        IntervalType yn = IntervalType (xleft [1], xright [1]);
 
        // create an interval that corresponds to the parameter of the system
        IntervalType a = IntervalType (getLeftParam (0), getRightParam (0));
 
        // compute the point at the next iteration using Euler's method
        // note: x' = y - x^3 + ax, y' = -x
        const double t (0.1);
#ifdef REVERSED_TIME
// [Vanderpol equations with reversed time:]
        IntervalType xn1 = xn - t * (yn - xn * (xn * xn - a));
        IntervalType yn1 = yn + t * xn;
#else
// [Vanderpol equations:]
        IntervalType xn1 = xn + t * (yn - xn * (xn * xn - a));
        IntervalType yn1 = yn - t * xn;
#endif
 
        // save the result
        yleft [0] = xn1. leftBound ();
        yright [0] = xn1. rightBound ();
        yleft [1] = yn1. leftBound ();
        yright [1] = yn1. rightBound ();
 
        // swich the rounding direction to the neutral one
        resetRounding ();
        return;
} /* MapVanderPol1::compute */
 
 
#endif // _CMGRAPHS_VPOL1_H_