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