/***************************************************************************/
/*                                                                         */
/*   Title: CODEPARL.G                                                     */
/*          includes  (1) trans (procedure)                                */
/*                    (2) back (procedure)                                 */
/*                    (3) decodec (procedure)                              */
/*                    (4) encodec (procedure)                              */
/*                                                                         */
/* modified from codeparc.g to eliminate consumption; for use with findjtl */
/*                                                                         */
/* Written: John H. Cochrane                                               */
/*      by: University of Chicago Graduate School of Business              */
/*          1101 E. 58th Street, Rosenwald 2xx                             */
/*          Chicago, Ill 60637                                             */
/*          ph#: (312) 702-3059                                            */
/*          e-mail: fac_jhc@gsbacd.uchicago.edu                            */
/*                                                                         */
/*Modified: Caleb C. Wong                                                  */
/*      by: University of Chicago Department of Economics                  */
/*          1126 East 59th St.                                             */
/*          Chicago, Ill 60637                                             */
/*          ph#: (312) 702-8254                                            */
/*          e-mail: wongcc@sam.spc.uchicago.edu                            */
/*                                                                         */
/* Purpose: The below procedures are all used to communicate parameters    */
/*          to &findjt.  Since the argument to optmum (&findjt) can only   */
/*          only accept the vector of parameters, and must be able to      */
/*          search from -inf to inf for values, these procs are necessary. */
/*                                                                         */
/*                                                                         */
/*                                                                         */
/***************************************************************************/

/* ------------------------------------------------------------------------*/
/* TRANS                                                                   */
/*                                                                         */
/* Purpose:                                                                */
/*        Takes alpha, delta, mpk, gam transforms them so that talpha      */
/*        tdelta tmpk tgam vary from -inf to inf while alpha delta mpk gam */
/*        stay in bounds.  Currently implementing gam.                     */
/*  Usage:                                                                 */
/*        {talpha,tdelta,tmpk,tgam} = trans(alpha,delta,mpk,gam);          */
/*                                                                         */
/* Inputs: (see above)                                                     */
/* Outputs: (see above)                                                    */
/* ------------------------------------------------------------------------*/

proc(3) = transl(alpha,delta,mpk);
    local talpha,tdelta,tmpk;
    talpha = alpha;
    tdelta = delta;
    tmpk = mpk;
    retp(talpha,tdelta,tmpk);
endp;

/* ------------------------------------------------------------------------*/
/* BACK                                                                    */
/*                                                                         */
/* Purpose:                                                                */
/*    Opposite of trans.  takes transformed parameters talpha .. and gives */
/*    back alpha delta mpk.  If you use, make sure trans(back(x)) = x      */
/*    and vice versa!                                                      */
/*                                                                         */
/* Usage:                                                                  */
/*      {alpha,delta,mpk,gam} = back(talpha,tdelta,tmpk,tgam);             */
/*                                                                         */
/* Inputs: (see above)                                                     */
/* Outputs: (see above)                                                    */
/* ------------------------------------------------------------------------*/

proc(3) = backl(talpha,tdelta,tmpk);
    local alpha,delta,mpk;
    alpha = talpha;
    delta = tdelta;
    mpk = tmpk;
    retp(alpha,delta,mpk);
endp;


/* --------------------------------------------------------------------------*/
/* DECODEC                                                                   */
/*                                                                           */
/* Purpose: Takes the transformed paramters and the default parameters and   */
/*          depending on selpar, returns either the 'de'-transform the       */
/*          tparms or returns the default parameters                         */
/*                                                                           */
/*   Usage:                                                                  */
/*  {alpha,delta,mpk,gam} = decodec(tparms,selpar,ccode,dalpha,ddelta,dmpk); */
/*                                                                           */
/*  Inputs:                                                                  */
/*    tparms: transformed parameters                                         */
/*    selpar: 3x1 vector of 1 or 0, tells you whether to search over the     */
/*            corresponding parameter.                                       */
/*     ccode: 1: consumption is in, 0 consumption is out.                    */
/*   dalpha,ddelta,dmpk: default parameters.  If selpar[j] = 0, returns this */
/*                       value rather than something taken from tpar.        */
/*                                                                           */
/*  Outputs:                                                                 */
/*  alpha delta mpk gamma.                                                   */
/*                                                                           */
/* --------------------------------------------------------------------------*/

proc(3) = decodel(tparms,selpar,dalpha,ddelta,dmpk);
    local npar,ni,counter,alpha,delta,mpk,talpha,tdelta,tmpk,
    dtalpha,dtdelta,dtmpk;

   {dtalpha,dtdelta,dtmpk} = transl(dalpha,ddelta,dmpk);

  if sumc(selpar) > 0;
    Npar = sumc(selpar);
    Ni = (rows(tparms))/Npar;
    counter = 0;
                          /* read transformed alpha etc. from tparms*/
    if selpar[1] == 1;
        talpha = tparms[1:Ni];
        counter = counter+1;
      else;
        talpha = dtalpha ;
    endif;
    if selpar[2] == 1;
        tdelta = tparms[counter*Ni+1:(counter+1)*Ni];
        counter = counter+1;
      else;
        tdelta = dtdelta   ;
    endif;
    if selpar[3] == 1;
        tmpk = tparms[counter*Ni+1:(counter+1)*Ni];
        counter = counter+1;
      else;
        tmpk = dtmpk;
    endif;
 else;
    talpha = dtalpha;
    tdelta = dtdelta;
    tmpk = dtmpk;
 endif;
 {alpha,delta,mpk} = backl(talpha,tdelta,tmpk);

    retp(alpha,delta,mpk);
endp;

/* ------------------------------------------------------------------------- */
/* ENCODEC                                                                   */
/*                                                                           */
/* Purpose:                                                                  */
/*                                                                           */
/*  Takes alpha delta mpk, constructs tparms, suitable for use by findjt.    */
/*  If selpar tells you a given parameter is not being searched over, it     */
/*  does not appear in tparms.                                               */
/*                                                                           */
/*   Usage:                                                                  */
/*      {tparms} = encode(alpha,delta,mpk,gam,selpar,ccode);                 */
/*                                                                           */
/*  Inputs: (see description in decodec)                                     */
/*                                                                           */
/* Outputs: (see description in decodec)                                     */
/* --------------------------------------------------------------------------*/

proc(1) = encodel(alpha,delta,mpk,selpar);
     local talpha,tdelta,tmpk,sizepar,npar,tparms,counter;

  {talpha,tdelta,tmpk} = transl(alpha,delta,mpk);
  if sumc(selpar) > 0;
    sizepar = rows(alpha);
    tparms = zeros(sizepar*sumc(selpar),1);
    counter = 0;
    if selpar[1] == 1;
        tparms[1:sizepar] = talpha;
        counter = counter+1;
    endif;
    if selpar[2] == 1;
        tparms[counter*sizepar+1:(counter+1)*sizepar] = tdelta;
        counter = counter+1;
    endif;
    if selpar[3] == 1;
        tparms[counter*sizepar+1:(counter+1)*sizepar] = tmpk;
        counter = counter+1;
    endif;
  endif;
    retp(tparms);
endp;