m_neuron1.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file m_neuron1.h
///
/// The nonlinear neuron model map.
///
/// This map defines the nonlinear Chialvo neuron model, based on the paper:
/// Dante R. Chialvo. Generic excitable dynamics on a two-dimensional map.
/// Chaos, Solitons & Fractals Vol. 5, Nos. 3/4, pp. 461-479, 1995.
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////
 
// Copyright (C) 1997-2021 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: February 21, 2008.
 
 
#ifndef _CMGRAPHS_NEURON1_H_
#define _CMGRAPHS_NEURON1_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"
 
// --------------------------------------------------
// ---------- the Chialvo neuron model map ----------
// --------------------------------------------------
 
/// This class defines a map for the nonlinear Chialvo neuron model map.
class MapNeuron1: public MapType
{
public:
        /// The default constructor.
        MapNeuron1 ();
 
        /// 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 MapNeuron1 */
 
// --------------------------------------------------
 
inline MapNeuron1::MapNeuron1 ()
{
        testIntervals ();
        return;
} /* MapNeuron1::MapNeuron1 */
 
inline void MapNeuron1::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]);
//      sbug << "xn = " << xn << "\n";
//      sbug << "yn = " << yn << "\n";
 
        // create intervals that correspond to the parameters of the system
        IntervalType a = IntervalType (getLeftParam (0), getRightParam (0));
        IntervalType b = IntervalType (getLeftParam (1), getRightParam (1));
        IntervalType c = IntervalType (getLeftParam (2), getRightParam (2));
        IntervalType k = IntervalType (getLeftParam (3), getRightParam (3));
//      sbug << "a = " << a << "\n";
//      sbug << "b = " << b << "\n";
//      sbug << "c = " << c << "\n";
//      sbug << "k = " << k << "\n";
 
        // compute the point at the next iteration
        IntervalType xn1 = sqr (xn) * exp (yn - xn) + k;
        IntervalType yn1 = a * yn - b * xn + c;
//      sbug << "xn1 = " << xn1 << "\n";
//      sbug << "yn1 = " << yn1 << "\n";
 
        // 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;
} /* MapNeuron1::compute */
 
 
#endif // _CMGRAPHS_NEURON1_H_