m_duffing_a.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file m_duffing_a.h
///
/// An approximate time-t map for the Duffing equations.
/// This map defines a sample time-t map for an ODE.
///
/// @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 December 28, 2010. Last revision: December 28, 2010.
 
 
#ifndef _CMGRAPHS_DUFAPPROX_H_
#define _CMGRAPHS_DUFAPPROX_H_
 
 
// include some standard C++ header files
#include <cmath>
 
// include local header files
#include "maptype.h"
#include "odeapprox.h"
 
 
// --------------------------------------------------
// ------------ the Vanderpol time-t map ------------
// --------------------------------------------------
 
/// An approximate time-t map for the Vanderpol equations.
class MapDuffingApprox: public MapOdeApprox
{
public:
        /// The constructor of a Vanderpol map object.
        MapDuffingApprox ();
 
private:
        /// The vector field.
        void vectorField (double, const double *x, double *y, int dim) const;
 
}; /* class MapDuffingApprox */
 
// --------------------------------------------------
 
inline MapDuffingApprox::MapDuffingApprox ():
        MapOdeApprox (2.0 * M_PI / 256.0, 256, 2)
{
        return;
} /* MapDuffingApprox::MapDuffingApprox */
 
inline void MapDuffingApprox::vectorField (double t,
        const double *x, double *y, int dim) const
{
        if (dim != 2)
                throw "This model is valid in dimension 2 only.";
 
        // is this equation with reversed time?
        const bool reversed = false;
 
        // retrieve the parameters (the left bound only)
        double a = getLeftParam (0);
        double b = getLeftParam (1);
 
        // compute the vector field
        y [0] = x [1];
        y [1] = x [0] - a * x [1] - x [0] * x [0] * x [0] +
                b * std::cos (t);
 
        // reverse the vector field if requested to
        if (reversed)
        {
                for (int i = 0; i < dim; ++ i)
                        y [i] = -y [i];
        }
 
        return;
} /* MapDuffingApprox::vectorField */
 
 
 
#endif // _CMGRAPHS_DUFAPPROX_H_