m_roessler_a.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file m_roessler_a.h
///
/// An approximate time-t map for the Roessler 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 May 26, 2011. Last revision: May 29, 2011.
 
 
#ifndef _CMGRAPHS_ROESAPPROX_H_
#define _CMGRAPHS_ROESAPPROX_H_
 
 
// include local header files
#include "maptype.h"
#include "odeapprox.h"
 
 
// --------------------------------------------------
// ------------ the Roessler time-t map -------------
// --------------------------------------------------
 
/// An approximate time-t map for the Roessler equations.
class MapRoesslerApprox: public MapOdeApprox
{
public:
        /// The constructor of a Roessler map object.
        MapRoesslerApprox ();
 
private:
        /// The vector field.
        void vectorField (double, const double *x, double *y, int dim) const;
 
}; /* class MapRoesslerApprox */
 
// --------------------------------------------------
 
inline MapRoesslerApprox::MapRoesslerApprox ():
        MapOdeApprox (1.0/64, 192, 2)
{
        return;
} /* MapRoesslerApprox::MapRoesslerApprox */
 
inline void MapRoesslerApprox::vectorField (double,
        const double *x, double *y, int dim) const
{
        if (dim != 3)
                throw "This model is valid in dimension 3 only.";
 
        // is this the Roessler equation with reversed time?
        const bool reversed = false;
 
        // retrieve the parameters (the left bound only)
        double a = getLeftParam (0);
        double b = getLeftParam (1);
 
        // scale the point in order to stretch the neighborhood
        const int sCount = 7;
        double sIn [sCount] =
                {-5, -1.0 / 4, -1.0 / 8, 0, 1.0 / 8, 1.0 / 4, 5};
        double sOut [sCount] =
                {-5, -2, -1, 0, 1, 2, 5};
        double scaled [3];
        for (int i = 0; i < 3; ++ i)
                scaled [i] = x [i];
        double stretch [3];
        for (int i = 0; i < 3; ++ i)
                stretch [i] = 1;
 
        const bool scaling = false;
        for (int i = 0; scaling && (i < 2); ++ i)
        {
                if ((x [i] <= sIn [0]) || (x [i] >= sIn [sCount - 1]))
                {
                        continue;
                }
                for (int j = 1; j < sCount; ++ j)
                {
                        if (x [i] < sIn [j])
                        {
                                stretch [i] = (sOut [j] - sOut [j - 1]) /
                                        (sIn [j] - sIn [j - 1]);
                                scaled [i] = sOut [j - 1] +
                                        (x [i] - sIn [j - 1]) * stretch [i];
                                break;
                        }
                }
        }
 
        // compute the vector field
        y [0] = (-(scaled [1] + scaled [2])) * stretch [0];
        y [1] = (scaled [0] + b * scaled [1]) * stretch [1];
        y [2] = (b + scaled [2] * (scaled [0] - a)) * stretch [2];
 
        // reverse the vector field if requested to
        if (reversed)
        {
                for (int i = 0; i < dim; ++ i)
                        y [i] = -y [i];
        }
 
        return;
} /* MapRoesslerApprox::vectorField */
 
 
 
#endif // _CMGRAPHS_ROESAPPROX_H_