m_whales.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file m_whales.h
///
/// The map for the whales population model.
///
/// This map defines a simple 2D nonlinear map
/// for modeling some whales population.
///
/// @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 February 9, 2008. Last revision: September 11, 2011.
 
 
#ifndef _CMGRAPHS_WHALES_H_
#define _CMGRAPHS_WHALES_H_
 
 
// some standard header files
#include <cmath>
 
// include local header files
#include "maptype.h"
#include "typeintv.h"
 
// for debugging
#include "chomp/system/textfile.h"
 
 
// --------------------------------------------------
// ------------- a population model map -------------
// --------------------------------------------------
 
/// This class defines a map for the nonlinear density dependent
/// overcompensatory Leslie population model.
/// The interpretation of parameters depends on the dimension.
class MapWhales: public MapType
{
public:
        /// The default constructor.
        MapWhales ();
 
        /// 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 MapWhales */
 
// --------------------------------------------------
 
inline MapWhales::MapWhales ()
{
        testIntervals ();
        return;
} /* MapWhales::MapWhales */
 
inline void MapWhales::compute (const double *xleft, const double *xright,
        double *yleft, double *yright, int dim, const spcCoord *, int) const
{
        // this formula is programmed for the phase space of dim 2 only
        if (dim != 2)
                throw "Whales population model: dim = 2 only!";
 
        // determine the number of adults and juveniles
        IntervalType adults (xleft [0], xright [0]);
        IntervalType juveniles (xleft [1], xright [1]);
 
        // prepare the interval version of the number one
        IntervalType one (1.0, 1.0);
 
        // determine the parameters
        IntervalType survivalRateA (getLeftParam (0), getRightParam (0));
        IntervalType survivalRateJ (getLeftParam (1), getRightParam (1));
        IntervalType alpha (getLeftParam (2), getRightParam (2));
        IntervalType beta (getLeftParam (3), getRightParam (3));
 
        // determine modifications of the model if any
        int options = static_cast<int> (getLeftParam (4));
        if (options & 0x010)
                survivalRateJ = one - survivalRateA;
        else if (options & 0x020)
                survivalRateJ = survivalRateA;
        if (options & 0x100)
        {
                // use the cached value of beta if possible
                static IntervalType alphaSaved (0.0, 0.0);
                static IntervalType betaSaved (0.0, 0.0);
                if ((alphaSaved. leftBound () == alpha. leftBound ()) &&
                        (alphaSaved. rightBound () == alpha. rightBound ()))
                {
                        beta = betaSaved;
                }
 
                // compute the approximate value of beta if alpha is a point
                else if (alpha. leftBound () == alpha. rightBound ())
                {
                        static double e = M_E; //std::exp (1.0);
                        double b = alpha. leftBound () / e;
                        beta = IntervalType (b, b);
                        alphaSaved = alpha;
                        betaSaved = beta;
                }
 
                // compute the interval vector for beta otherwise
                else
                {
                        static IntervalType e = exp (one);
                        beta = alpha / e;
                        alphaSaved = alpha;
                        betaSaved = beta;
                }
        }
 
        // compute the intervals of the output values
        IntervalType newAdults (survivalRateJ * juveniles +
                survivalRateA * adults);
        IntervalType newJuveniles (alpha * adults * exp (-beta * adults));
 
        // copy the bounds of the intervals to the output variables
        yleft [0] = newAdults. leftBound ();
        yright [0] = newAdults. rightBound ();
        yleft [1] = newJuveniles. leftBound ();
        yright [1] = newJuveniles. rightBound ();
 
        // make a correction of non-positive values to ensure isolation
//      for (int i = 0; i < dim; ++ i)
//      {
//              if (yleft [i] <= 0)
//                      yleft [i] = 1e-10;
//              if (yright [i] < yleft [i])
//                      yright [i] = yleft [i];
//      }
 
        // swich the rounding direction to the neutral one
        resetRounding ();
        return;
} /* MapWhales::compute */
 
 
#endif // _CMGRAPHS_WHALES_H_