m_globclog.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file m_globclog.h
///
/// Globally coupled logistic maps.
///
/// This map defines the transformation for globally coupled logistic maps.
///
/// @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 April 10, 2008. Last revision: September 13, 2010.
 
 
#ifndef _CMGRAPHS_GLOBCLOG_H_
#define _CMGRAPHS_GLOBCLOG_H_
 
// some standard header files
#include <cmath>
 
// the generic class for the type of a map
#include "maptype.h"
 
// the interval arithmetic data types
#include "typeintv.h"
 
 
// --------------------------------------------------
// -------- the Leslie population model map ---------
// --------------------------------------------------
 
/// This class defines a map which describes a family of globally coupled
/// logistic maps.
/// There are only two parameters of this map: 'a' and 'epsilon'.
/// Warning: This class is not thread-safe!
class MapGlobCLog: public MapType
{
public:
        /// The default constructor.
        MapGlobCLog ();
 
        /// The destructor.
        ~MapGlobCLog ();
 
        /// 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;
 
private:
        /// Configuration option: Is this the weighted 2GCM model?
        static const bool weighted2GCM = true;
 
        /// Configuration option: Should we change the first two coordinates?
        static const bool changeCoordinates = false;
 
        /// The extra weights for the maps (for the weighted 2GCM).
        mutable int *sigma;
 
        /// The sum of the sigmas.
        mutable int sigmaSum;
 
        /// A temporary array for the variables.
        mutable IntervalType *variables;
 
        /// The dimension for which the internal arrays have been allocated.
        mutable int currentDim;
 
        /// Rescaling factor for the changed coordinates.
        double rescaling;
 
        /// The logistic function f_a (x) = 1 - a x^2.
        static IntervalType logistic (const IntervalType &x,
                const IntervalType &a);
 
        /// Sets the space dimension and (re-)allocates memory
        /// for the sigma coefficients and variables.
        void setDimension (int dim) const;
 
        /// Applies a coordinate change to the input vector.
        IntervalType *changeCoordsIn (IntervalType *input,
                IntervalType *output, int dim) const;
 
        /// Applies a coordinate change to the output vector.
        IntervalType *changeCoordsOut (IntervalType *input,
                IntervalType *output, int dim) const;
 
}; /* class MapGlobCLog */
 
// --------------------------------------------------
 
inline MapGlobCLog::MapGlobCLog ():
        sigma (0), sigmaSum (0), variables (0), currentDim (0),
        rescaling (std::sqrt (2.0))
{
        testIntervals ();
        return;
} /* MapGlobCLog::MapGlobCLog */
 
inline MapGlobCLog::~MapGlobCLog ()
{
        if (sigma)
                delete [] sigma;
        sigma = 0;
        if (variables)
                delete [] variables;
        variables = 0;
        return;
} /* MapGlobCLog::~MapGlobCLog */
 
inline IntervalType MapGlobCLog::logistic (const IntervalType &x,
        const IntervalType &a)
{
        return 1 - a * x * x;
} /* MapGlobCLog::logistic */
 
inline void MapGlobCLog::setDimension (int dim) const
{
        if (currentDim == dim)
                return;
        if (sigma)
                delete [] sigma;
        if (variables)
                delete [] variables;
        currentDim = dim;
        sigma = new int [currentDim];
        variables = new IntervalType [2 * currentDim];
        sigmaSum = 0;
        for (int i = 0; i < dim; ++ i)
        {
                sigma [i] = 1;
                if (weighted2GCM && (dim == 2) && (i == 0))
                        sigma [i] = 2;
                sigmaSum += sigma [i];
        }
        return;
} /* MapGlobCLog::setDimension */
 
inline IntervalType *MapGlobCLog::changeCoordsIn (IntervalType *input,
        IntervalType *output, int dim) const
{
        if (!changeCoordinates)
                return input;
        output [0] = (input [0] - input [1]) / 2 * rescaling;
        output [1] = (input [0] + input [1]) / 2 * rescaling;
        for (int i = 2; i < dim; ++ i)
                output [i] = input [i];
        return output;
} /* MapGlobCLog::changeCoordsIn */
 
inline IntervalType *MapGlobCLog::changeCoordsOut (IntervalType *input,
        IntervalType *output, int dim) const
{
        if (!changeCoordinates)
                return input;
        output [0] = (input [0] + input [1]) / rescaling;
        output [1] = (input [1] - input [0]) / rescaling;
        for (int i = 2; i < dim; ++ i)
                output [i] = input [i];
        return output;
} /* MapGlobCLog::changeCoordsOut */
 
inline void MapGlobCLog::compute (const double *xleft, const double *xright,
        double *yleft, double *yright, int dim, const spcCoord *, int) const
{
        // set the dimension for the sigmas and other temporary variables
        setDimension (dim);
 
        // create the intervals of the argument variables
        for (int i = 0; i < dim; ++ i)
        {
                variables [i] = IntervalType (xleft [i], xright [i]);
        }
 
        // apply a coordinate change transformation if necessary
        IntervalType *newVariables =
                changeCoordsIn (variables, variables + dim, dim);
 
        // determine the parameter 'a'
        IntervalType a (getLeftParam (0), getRightParam (0));
 
        // compute the logistic maps on all the variables
        IntervalType *images = variables;
        for (int i = 0; i < dim; ++ i)
        {
                images [i] = logistic (newVariables [i], a);
        }
 
        // compute the average of the logistic maps on the domain
        IntervalType average (0.0, 0.0);
        for (int i = 0; i < dim; ++ i)
        {
                if (sigma [i] == 1)
                        average += variables [i];
                else
                        average += sigma [i] * variables [i];
        }
 
        // determine the epsilon parameter and set 1-eps
        IntervalType epsilon (getLeftParam (1), getRightParam (1));
        IntervalType oneminuseps = 1 - epsilon;
 
        // make a correction to the average that is to be added
        average *= epsilon;
        average /= sigmaSum;
 
        // compute the results
        IntervalType *results = variables + dim;
        for (int i = 0; i < dim; ++ i)
        {
                results [i] = oneminuseps * images [i] + average;
        }
 
        // apply a coordinate change transformation if necessary
        IntervalType *newResults =
                changeCoordsOut (variables + dim, variables, dim);
 
        // extract the images from the intervals
        for (int i = 0; i < dim; ++ i)
        {
                yleft [i] = newResults [i]. leftBound ();
                yright [i] = newResults [i]. rightBound ();
        }
 
        // swich the rounding direction to the neutral one
        resetRounding ();
        return;
} /* MapGlobCLog::compute */
 
 
#endif // _CMGRAPHS_GLOBCLOG_H_