ADMB Documentation  11.5.3297
 All Classes Files Functions Variables Typedefs Friends Defines
model21.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 void param_init_d3array::set_simulation_bounds(const dmatrix& symbds,
00010   const int& ii)
00011 {
00012  cerr << " Error -- void param_init_d3array::set_simulation_bounds"
00013    " (const dmatrix& symbds, const int& ii) has not yet been defined" << endl;
00014  exit(1);
00015 }
00016 */
00017 
00018 void param_init_d3array::get_jacobian(const dvector& y, const dvector& ndev,
00019   const int& ii)
00020 {
00021  cerr << " Error -- "
00022    " void param_init_number::add_value(const dvector& ndev, const int& ii)"
00023    " has not yet been defined" << endl;
00024  exit(1);
00025 }
00026 
00027 const char * param_init_d3array::label(void)
00028 {
00029   return model_name_tag::label().mychar();
00030 }
00031 
00032 param_init_d3array::param_init_d3array() : named_dvar3_array() ,
00033   initial_params()
00034 {
00035   //add_to_list();
00036 }
00037 
00038 int param_init_d3array::size_count(void)
00039 {
00040   return ::size_count(*this);
00041 }
00042 
00043 void param_init_d3array::save_value(ofstream& ofs)
00044 {
00045   if (!(!(*this)))
00046     ofs << label_class(this->label()) << dvar3_array(*this) << endl;
00047 }
00048 
00049 void param_init_d3array::bsave_value(uostream& uos)
00050 {
00051   if (!(!(*this)))
00052   {
00053     dvar3_array& tmp = *this;
00054     uos << tmp;
00055   }
00056 }
00057 
00058 void param_init_d3array::set_value(const dvar_vector& x,
00059   const int& ii, const dvariable& pen)
00060   {
00061     ::set_value(*this,x,ii);
00062   }
00063 
00064 void param_init_d3array::set_value_inv(const dvector& x, const int& ii)
00065   {
00066     ::set_value_inv(*this,x,ii);
00067   }
00068 
00069 void param_init_d3array::copy_value_to_vector(const dvector& x, const int& ii)
00070   {
00071     ::copy_value_to_vector(*this,x,ii);
00072   }
00073 
00074 void param_init_d3array::restore_value_from_vector(const dvector& x,
00075   const int& ii)
00076   {
00077     ::restore_value_from_vector(*this,x,ii);
00078   }
00079 
00080 void param_init_d3array::save_value(const ofstream& _ofs,int prec)
00081   {
00082     ofstream& ofs=(ofstream&) _ofs;
00083     ofs << setw(prec+6) << setprecision(prec) << dvar3_array(*this) << endl;
00084   }
00085 
00091 void param_init_d3array::allocate(int smin, int smax, int rmin, int rmax,
00092   int cmin, int cmax, const char* s)
00093 {
00094   allocate(smin, smax, rmin, rmax, cmin, cmax, 1, s);
00095 }
00101 void param_init_d3array::allocate(const ad_integer& sl,
00102   const ad_integer& sh,const index_type& nrl,const index_type& nrh,
00103   const index_type& ncl,const index_type& nch,const char * s)
00104 {
00105   allocate(sl, sh, nrl, nrh, ncl, nch, 1, s);
00106 }
00112 void param_init_d3array::allocate(
00113   const ad_integer& sl, const ad_integer& sh,
00114   const index_type& nrl, const index_type& nrh,
00115   const index_type& ncl, const index_type& nch,
00116   int _phase_start, const char * s)
00117 {
00118   named_dvar3_array::allocate(sl,sh,nrl,nrh,ncl,nch,s);
00119   initial_params::allocate(_phase_start);
00120   if (!(!(*this)))
00121   {
00122     for (int i=indexmin();i<=indexmax();i++)
00123     {
00124       if (allocated((*this)(i)))
00125       {
00126         for (int j=(*this)(i).indexmin();j<=(*this)(i).indexmax();j++)
00127         {
00128           if (allocated((*this)(i,j)))
00129           {
00130             if (ad_comm::global_bparfile)
00131             {
00132               *(ad_comm::global_bparfile) >> (*this)(i,j);
00133             }
00134             else if (ad_comm::global_parfile)
00135             {
00136               *(ad_comm::global_parfile) >> (*this)(i,j);
00137             }
00138             else
00139             {
00140               (*this)(i,j)=(initial_value);
00141             }
00142           }
00143         }
00144       }
00145     }
00146   }
00147 }
00153 void param_init_d3array::allocate( int smin, int smax, int rmin, int rmax,
00154   int cmin, int cmax, int _phase_start, const char* s)
00155 {
00156   named_dvar3_array::allocate(smin,smax,rmin,rmax,cmin,cmax,s);
00157   initial_params::allocate(_phase_start);
00158   if (!(!(*this)))
00159   {
00160     for (int i=indexmin();i<=indexmax();i++)
00161     {
00162       if (allocated((*this)(i)))
00163       {
00164         if (ad_comm::global_bparfile)
00165         {
00166           *(ad_comm::global_bparfile) >> (*this)(i);
00167         }
00168         else if (ad_comm::global_parfile)
00169         {
00170           *(ad_comm::global_parfile) >> (*this)(i);
00171         }
00172         else
00173         {
00174           (*this)(i) = (initial_value);
00175         }
00176       }
00177     }
00178   }
00179 }
00180 
00181 void param_init_d3array::curv_scale(const dvector& _v, const dvector& x,
00182   const int& _ii)
00183   {
00184     int& ii=(int&) _ii;
00185     dvector& v=(dvector&) _v;
00186     int smin=slicemin();
00187     int smax=slicemax();
00188     for (int k=smin;k<=smax;k++)
00189     {
00190       int mmin=(*this)(k).rowmin();
00191       int mmax=(*this)(k).rowmax();
00192       for (int i=mmin;i<=mmax;i++)
00193       {
00194         int cmin=((*this)(k,i)).indexmin();
00195         int cmax=((*this)(k,i)).indexmax();
00196         for (int j=cmin;j<=cmax;j++)
00197         {
00198           v(ii++)=0.;
00199         }
00200       }
00201     }
00202   }
00203 
00204 void param_init_d3array::hess_scale(const dvector& _v, const dvector& x,
00205   const int& _ii)
00206   {
00207     int& ii=(int&) _ii;
00208     dvector& v=(dvector&) _v;
00209     int smin=slicemin();
00210     int smax=slicemax();
00211     for (int k=smin;k<=smax;k++)
00212     {
00213       int mmin=(*this)(k).rowmin();
00214       int mmax=(*this)(k).rowmax();
00215       for (int i=mmin;i<=mmax;i++)
00216       {
00217         int cmin=((*this)(k,i)).indexmin();
00218         int cmax=((*this)(k,i)).indexmax();
00219         for (int j=cmin;j<=cmax;j++)
00220         {
00221           v(ii++)=0.;
00222         }
00223       }
00224     }
00225   }
00226 
00227 void param_init_d3array::sd_scale(const dvector& _v, const dvector& x,
00228   const int& _ii)
00229   {
00230     int& ii=(int&) _ii;
00231     dvector& v=(dvector&) _v;
00232     if (allocated(*this))
00233     {
00234       int smin=slicemin();
00235       int smax=slicemax();
00236       for (int k=smin;k<=smax;k++)
00237       {
00238         if (allocated((*this)(k)))
00239         {
00240           int mmin=(*this)(k).rowmin();
00241           int mmax=(*this)(k).rowmax();
00242           for (int i=mmin;i<=mmax;i++)
00243           {
00244             if (allocated((*this)(k,i)))
00245             {
00246               int cmin=((*this)(k,i)).indexmin();
00247               int cmax=((*this)(k,i)).indexmax();
00248               for (int j=cmin;j<=cmax;j++)
00249               {
00250                 v(ii++)=1.;
00251               }
00252             }
00253           }
00254         }
00255       }
00256     }
00257   }
00258 
00259 cifstream& operator>>(const cifstream& _s, param_init_d3array& m)
00260 {
00261   cifstream&  s=(cifstream&) _s;
00262   s >> dvar3_array(m);
00263   return s;
00264 }
00265 
00266 void param_init_d3array::restore_value(const ifstream& ofs)
00267 {
00268   ofs  >> dvar3_array(*this);
00269 }