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