ADMB Documentation  11.1.2490
 All Classes Files Functions Variables Typedefs Friends Defines
model6.cpp
Go to the documentation of this file.
00001 /*
00002  * $Id: model6.cpp 1919 2014-04-22 22:02:01Z johnoel $
00003  *
00004  * Author: David Fournier
00005  * Copyright (c) 2008-2012 Regents of the University of California
00006  */
00007 #include <admodel.h>
00008 
00009 void param_init_bounded_matrix::set_value(const dvar_vector& x,
00010   const int& ii, const dvariable& pen)
00011   {
00012     if (allocated(*this))
00013     {
00014       if (!scalefactor)
00015         ::set_value(*this,x,ii,minb,maxb,pen);
00016       else
00017         ::set_value(*this,x,ii,minb,maxb,pen,scalefactor);
00018     }
00019   }
00020 
00021 
00022 void param_init_bounded_matrix::set_value_inv(const dvector& x, const int& ii)
00023   {
00024     if (allocated(*this))
00025     {
00026       if (!scalefactor)
00027         ::set_value_inv(*this,x,ii,minb,maxb);
00028       else
00029         ::set_value_inv(*this,x,ii,minb,maxb,scalefactor);
00030     }
00031   }
00032 
00033   param_init_bounded_matrix::param_init_bounded_matrix() :
00034     param_init_matrix()
00035   {;}
00036 
00037   void param_init_bounded_matrix::allocate(int rmin,int rmax,
00038     int cmin,int cmax,
00039     double _minb,double _maxb,int _phase_start,const char * s)
00040   {
00041     minb=_minb;
00042     maxb=_maxb;
00043     dvar_matrix::allocate(rmin,rmax,cmin,cmax);
00044     model_name_tag::allocate(s);
00045     if (allocated(*this))
00046     {
00047       initial_params::allocate(_phase_start);
00048       for (int i=indexmin();i<=indexmax();i++)
00049       {
00050         if (allocated((*this)(i)))
00051         {
00052           if (ad_comm::global_bparfile)
00053           {
00054             *(ad_comm::global_bparfile) >> (*this)(i);
00055           }
00056           else if (ad_comm::global_parfile)
00057           {
00058             *(ad_comm::global_parfile) >> (*this)(i);
00059           }
00060           else
00061           {
00062             if ((!initial_value_flag) || initial_value <=minb
00063                  || initial_value >= maxb)
00064             {
00065               //cerr << "Initial value out of bounds -- using halfway value\n.";
00066               initial_value=(minb+maxb)/2.;
00067             }
00068             (*this)(i)=(initial_value);
00069           }
00070         }
00071       }
00072     }
00073     else
00074     {
00075       initial_params::allocate(-1);
00076     }
00077   }
00078 
00079   void param_init_bounded_matrix::allocate(int rmin,int rmax,
00080     int cmin,int cmax,double _minb,double _maxb,const char * s)
00081   {
00082     minb=_minb;
00083     maxb=_maxb;
00084     dvar_matrix::allocate(rmin,rmax,cmin,cmax);
00085     model_name_tag::allocate(s);
00086     if (allocated(*this))
00087     {
00088       initial_params::allocate(1);
00089       for (int i=indexmin();i<=indexmax();i++)
00090       {
00091         if (allocated((*this)(i)))
00092         {
00093           if (ad_comm::global_bparfile)
00094           {
00095             *(ad_comm::global_bparfile) >> (*this)(i);
00096           }
00097           else if (ad_comm::global_parfile)
00098           {
00099             *(ad_comm::global_parfile) >> (*this)(i);
00100           }
00101           else
00102           {
00103             if ((!initial_value_flag) || initial_value <=minb
00104                  || initial_value >= maxb)
00105             {
00106               //cerr << "Initial value out of bounds -- using halfway value\n.";
00107               initial_value=(minb+maxb)/2.;
00108             }
00109             (*this)(i)=(initial_value);
00110           }
00111        }
00112       }
00113     }
00114     else
00115     {
00116       initial_params::allocate(-1);
00117     }
00118   }
00119 
00120 void param_init_bounded_matrix::allocate(const ad_integer& rmin,
00121   const ad_integer& rmax, const index_type& cmin,
00122   const index_type& cmax, double _minb,double _maxb,
00123     int _phase_start,const char * s)
00124   {
00125     minb=_minb;
00126     maxb=_maxb;
00127     dvar_matrix::allocate(rmin,rmax,cmin,cmax);
00128     model_name_tag::allocate(s);
00129     if (allocated(*this))
00130     {
00131       initial_params::allocate(_phase_start);
00132       for (int i=indexmin();i<=indexmax();i++)
00133       {
00134         if (allocated((*this)(i)))
00135         {
00136           if (ad_comm::global_bparfile)
00137           {
00138             *(ad_comm::global_bparfile) >> (*this)(i);
00139           }
00140           else if (ad_comm::global_parfile)
00141           {
00142             *(ad_comm::global_parfile) >> (*this)(i);
00143           }
00144           else
00145           {
00146             if ((!initial_value_flag) || initial_value <=minb
00147                  || initial_value >= maxb)
00148             {
00149               //cerr << "Initial value out of bounds -- using halfway value\n.";
00150               initial_value=(minb+maxb)/2.;
00151             }
00152             (*this)(i)=(initial_value);
00153           }
00154         }
00155       }
00156     }
00157     else
00158     {
00159       initial_params::allocate(-1);
00160     }
00161   }
00162 
00163 
00164 void param_init_bounded_matrix::allocate(const ad_integer& rmin,
00165   const ad_integer& rmax, const index_type& cmin,
00166   const index_type& cmax, double _minb, double _maxb,
00167   const char* s)
00168   {
00169     minb=_minb;
00170     maxb=_maxb;
00171     dvar_matrix::allocate(rmin,rmax,cmin,cmax);
00172     model_name_tag::allocate(s);
00173     if (allocated(*this))
00174     {
00175       initial_params::allocate(1);
00176       for (int i=indexmin();i<=indexmax();i++)
00177       {
00178         if (allocated((*this)(i)))
00179         {
00180           if (ad_comm::global_bparfile)
00181           {
00182             *(ad_comm::global_bparfile) >> (*this)(i);
00183           }
00184           else if (ad_comm::global_parfile)
00185           {
00186             *(ad_comm::global_parfile) >> (*this)(i);
00187           }
00188           else
00189           {
00190             if ((!initial_value_flag) || initial_value <=minb
00191                  || initial_value >= maxb)
00192             {
00193               //cerr << "Initial value out of bounds -- using halfway value\n.";
00194               initial_value=(minb+maxb)/2.;
00195             }
00196             (*this)(i)=(initial_value);
00197           }
00198         }
00199       }
00200     }
00201     else
00202     {
00203       initial_params::allocate(-1);
00204     }
00205   }