imach/src/imach.c - diff

Return to imach.c CVS log

Up to [Local Repository] / imach / src

Diff for /imach/src/imach.c between versions 1.343 and 1.360

-version 1.343, 2022/09/14 14:22:16
+version 1.360, 2024/04/30 10:59:22
  Line 1
  /* $Id$
    $State$
    $Log$
+   Revision 1.360  2024/04/30 10:59:22  brouard
+   Summary: Version 0.99s4 and estimation of std of e.j/e..
+   Revision 1.359  2024/04/24 21:21:17  brouard
+   Summary: First IMaCh version using Brent Praxis software based on Buckhardt and Gegenfürtner C codes
+   Revision 1.6  2024/04/24 21:10:29  brouard
+   Summary: First IMaCh version using Brent Praxis software based on Buckhardt and Gegenfürtner C codes
+   Revision 1.5  2023/10/09 09:10:01  brouard
+   Summary: trying to reconsider
+   Revision 1.4  2023/06/22 12:50:51  brouard
+   Summary: stil on going
+   Revision 1.3  2023/06/22 11:28:07  brouard
+   *** empty log message ***
+   Revision 1.2  2023/06/22 11:22:40  brouard
+   Summary: with svd but not working yet
+   Revision 1.353  2023/05/08 18:48:22  brouard
+   *** empty log message ***
+   Revision 1.352  2023/04/29 10:46:21  brouard
+   *** empty log message ***
+   Revision 1.351  2023/04/29 10:43:47  brouard
+   Summary: 099r45
+   Revision 1.350  2023/04/24 11:38:06  brouard
+   *** empty log message ***
+   Revision 1.349  2023/01/31 09:19:37  brouard
+   Summary: Improvements in models with age*Vn*Vm
+   Revision 1.347  2022/09/18 14:36:44  brouard
+   Summary: version 0.99r42
+   Revision 1.346  2022/09/16 13:52:36  brouard
+   * src/imach.c (Module): 0.99r41 Was an error when product of timevarying and fixed. Using FixedV[of name] now. Thank you  Feinuo
+   Revision 1.345  2022/09/16 13:40:11  brouard
+   Summary: Version 0.99r41
+   * imach.c (Module): 0.99r41 Was an error when product of timevarying and fixed. Using FixedV[of name] now. Thank you  Feinuo
+   Revision 1.344  2022/09/14 19:33:30  brouard
+   Summary: version 0.99r40
+   * imach.c (Module): Fixing names of variables in T_ (thanks to Feinuo)
    Revision 1.343  2022/09/14 14:22:16  brouard
    Summary: version 0.99r39
- Line 1247  Important routines
+ Line 1299  Important routines
  /* #define POWELLORIGINAL /\* Don't use Directest to decide new direction but original Powell test *\/ */
  /* #define MNBRAKORIGINAL /\* Don't use mnbrak fix *\/ */
  /* #define FLATSUP  *//* Suppresses directions where likelihood is flat */
+ /* #define POWELLORIGINCONJUGATE  /\* Don't use conjugate but biggest decrease if valuable *\/ */
+ /* #define NOTMINFIT */
  #include <math.h>
  #include <stdio.h>
- Line 1298  typedef struct {
+ Line 1352  typedef struct {
  /* #include <libintl.h> */
  /* #define _(String) gettext (String) */
- #define MAXLINE 2048 /* Was 256 and 1024. Overflow with 312 with 2 states and 4 covariates. Should be ok */
+ #define MAXLINE 16384 /* Was 256 and 1024 and 2048. Overflow with 312 with 2 states and 4 covariates. Should be ok */
  #define GNUPLOTPROGRAM "gnuplot"
  #define GNUPLOTVERSION 5.1
- Line 1309  double gnuplotversion=GNUPLOTVERSION;
+ Line 1363  double gnuplotversion=GNUPLOTVERSION;
  #define GLOCK_ERROR_NOPATH              -1      /* empty path */
  #define GLOCK_ERROR_GETCWD              -2      /* cannot get cwd */
- #define MAXPARM 128 /**< Maximum number of parameters for the optimization */
+ #define MAXPARM 216 /**< Maximum number of parameters for the optimization was 128 */
  #define NPARMAX 64 /**< (nlstate+ndeath-1)*nlstate*ncovmodel */
  #define NINTERVMAX 8
- Line 1343  double gnuplotversion=GNUPLOTVERSION;
+ Line 1397  double gnuplotversion=GNUPLOTVERSION;
  /* $State$ */
  #include "version.h"
  char version[]=__IMACH_VERSION__;
- char copyright[]="September 2022,INED-EUROREVES-Institut de longevite-Japan Society for the Promotion of Science (Grant-in-Aid for Scientific Research 25293121), Intel Software 2015-2020, Nihon University 2021-202, INED 2000-2022";
+ char copyright[]="April 2024,INED-EUROREVES-Institut de longevite-Japan Society for the Promotion of Science (Grant-in-Aid for Scientific Research 25293121), Intel Software 2015-2020, Nihon University 2021-202, INED 2000-2024";
  char fullversion[]="$Revision$ $Date$";
  char strstart[80];
  char optionfilext[10], optionfilefiname[FILENAMELENGTH];
- Line 1357  int cptcovt=0; /**< cptcovt: total numbe
+ Line 1411  int cptcovt=0; /**< cptcovt: total numbe
  int cptcovs=0; /**< cptcovs number of SIMPLE covariates in the model V2+V1 =2 (dummy or quantit or time varying) */
  int cptcovsnq=0; /**< cptcovsnq number of SIMPLE covariates in the model but non quantitative V2+V1 =2 */
  int cptcovage=0; /**< Number of covariates with age: V3*age only =1 */
+ int cptcovprodage=0; /**< Number of fixed covariates with age: V3*age or V2*V3*age 1 */
+ int cptcovprodvage=0; /**< Number of varying covariates with age: V7*age or V7*V6*age */
+ int cptcovdageprod=0; /**< Number of doubleproducts with age, since 0.99r44 only: age*Vn*Vm for gnuplot printing*/
  int cptcovprodnoage=0; /**< Number of covariate products without age */
  int cptcoveff=0; /* Total number of single dummy covariates (fixed or time varying) to vary for printing results (2**cptcoveff combinations of dummies)(computed in tricode as cptcov) */
  int ncovf=0; /* Total number of effective fixed covariates (dummy or quantitative) in the model */
  int ncovv=0; /* Total number of effective (wave) varying covariates (dummy or quantitative) in the model */
  int ncovvt=0; /* Total number of effective (wave) varying covariates (dummy or quantitative or products [without age]) in the model */
- int ncova=0; /* Total number of effective (wave and stepm) varying with age covariates (dummy of quantitative) in the model */
+ int ncovvta=0; /*  +age*V6 + age*V7+ age*V6*V3 +age*V7*V3 + age*V6*V4 +age*V7*V4 Total number of expandend products [with age]) in the model */
+ int ncovta=0; /*age*V3*V2 +age*V2+agev3+ageV4  +age*V6 + age*V7+ age*V6*V3 +age*V7*V3 + age*V6*V4 +age*V7*V4 Total number of expandend products [with age]) in the model */
+ int ncova=0; /* Total number of effective (wave and stepm) varying with age covariates (single or product, dummy or quantitative) in the model */
+ int ncovva=0; /* +age*V6 + age*V7+ge*V6*V3 +age*V7*V3 + age*V6*V4 +age*V7*V4 Total number of effective (wave and stepm) varying with age covariates (single or product, dummy or quantitative) in the model */
  int nsd=0; /**< Total number of single dummy variables (output) */
  int nsq=0; /**< Total number of single quantitative variables (output) */
  int ncoveff=0; /* Total number of effective fixed dummy covariates in the model */
- Line 1385  int *wav; /* Number of waves for this in
+ Line 1445  int *wav; /* Number of waves for this in
  int maxwav=0; /* Maxim number of waves */
  int jmin=0, jmax=0; /* min, max spacing between 2 waves */
  int ijmin=0, ijmax=0; /* Individuals having jmin and jmax */
- int gipmx=0, gsw=0; /* Global variables on the number of contributions
+ int gipmx = 0;
+ double gsw = 0; /* Global variables on the number of contributions
                     to the likelihood and the sum of weights (done by funcone)*/
  int mle=1, weightopt=0;
  int **mw; /* mw[mi][i] is number of the mi wave for this individual */
- Line 1449  extern time_t time();
+ Line 1510  extern time_t time();
  struct tm start_time, end_time, curr_time, last_time, forecast_time;
  time_t  rstart_time, rend_time, rcurr_time, rlast_time, rforecast_time; /* raw time */
+ time_t   rlast_btime; /* raw time */
  struct tm tm;
  char strcurr[80], strfor[80];
- Line 1552  int **nbcode, *Tvar; /**< model=V2 => Tv
+ Line 1614  int **nbcode, *Tvar; /**< model=V2 => Tv
    # States 1=Coresidence, 2 Living alone, 3 Institution
    # V1=sex, V2=raedyrs Quant Fixed, State=livarnb4..livarnb11, V3=iadl4..iald11, V4=adlw4..adlw11, V5=r4bmi..r11bmi
  */
- /*           V5+V4+ V3+V4*V3 +V5*age+V2 +V1*V2+V1*age+V1 */
+ /*           V5+V4+ V3+V4*V3 +V5*age+V2 +V1*V2+V1*age+V1+V4*V3*age */
- /*    kmodel  1  2   3   4     5    6    7     8    9 */
+ /*    kmodel  1  2   3    4     5     6    7     8     9    10 */
- /*Typevar[k]=  0  0   0   2     1    0    2     1    0 *//*0 for simple covariate (dummy, quantitative,*/
+ /*Typevar[k]=  0  0   0   2     1    0    2     1     0    3 *//*0 for simple covariate (dummy, quantitative,*/
-                                                          /* fixed or varying), 1 for age product, 2 for*/
+                                                                /* fixed or varying), 1 for age product, 2 for*/
-                                                          /* product */
+                                                                /* product without age, 3 for age and double product   */
- /*Dummy[k]=    1  0   0   1     3    1    1     2    0 *//*Dummy[k] 0=dummy (0 1), 1 quantitative */
+ /*Dummy[k]=    1  0   0   1     3    1    1     2     0     3  *//*Dummy[k] 0=dummy (0 1), 1 quantitative */
-                                                          /*(single or product without age), 2 dummy*/
+                                                                 /*(single or product without age), 2 dummy*/
-                                                          /* with age product, 3 quant with age product*/
+                                                                /* with age product, 3 quant with age product*/
- /*Tvar[k]=     5  4   3   6     5    2    7     1    1 */
+ /*Tvar[k]=     5  4   3   6     5    2    7     1     1     6 */
- /*    nsd         1   2                              3 */ /* Counting single dummies covar fixed or tv */
+ /*    nsd         1   2                               3 */ /* Counting single dummies covar fixed or tv */
- /*TnsdVar[Tvar]   1   2                              3 */
+ /*TnsdVar[Tvar]   1   2                               3 */
- /*Tvaraff[nsd]     4   3                              1 */ /* ID of single dummy cova fixed or timevary*/
+ /*Tvaraff[nsd]    4   3                               1 */ /* ID of single dummy cova fixed or timevary*/
- /*TvarsD[nsd]     4   3                              1 */ /* ID of single dummy cova fixed or timevary*/
+ /*TvarsD[nsd]     4   3                               1 */ /* ID of single dummy cova fixed or timevary*/
- /*TvarsDind[nsd]  2   3                              9 */ /* position K of single dummy cova */
+ /*TvarsDind[nsd]  2   3                               9 */ /* position K of single dummy cova */
- /*    nsq      1                     2                 */ /* Counting single quantit tv */
+ /*    nsq      1                     2                  */ /* Counting single quantit tv */
- /* TvarsQ[k]   5                     2                 */ /* Number of single quantitative cova */
+ /* TvarsQ[k]   5                     2                  */ /* Number of single quantitative cova */
- /* TvarsQind   1                     6                 */ /* position K of single quantitative cova */
+ /* TvarsQind   1                     6                  */ /* position K of single quantitative cova */
- /* Tprod[i]=k             1               2            */ /* Position in model of the ith prod without age */
+ /* Tprod[i]=k             1               2             */ /* Position in model of the ith prod without age */
- /* cptcovage                    1               2      */ /* Counting cov*age in the model equation */
+ /* cptcovage                    1               2         3 */ /* Counting cov*age in the model equation */
- /* Tage[cptcovage]=k            5               8      */ /* Position in the model of ith cov*age */
+ /* Tage[cptcovage]=k            5               8         10 */ /* Position in the model of ith cov*age */
- /* Tvard[1][1]@4={4,3,1,2}    V4*V3 V1*V2              */ /* Position in model of the ith prod without age */
+ /* model="V2+V3+V4+V6+V7+V6*V2+V7*V2+V6*V3+V7*V3+V6*V4+V7*V4+age*V2+age*V3+age*V4+age*V6+age*V7+age*V6*V2+age*V6*V3+age*V7*V3+age*V6*V4+age*V7*V4\r"*/
+ /*  p Tvard[1][1]@21 = {6, 2, 7, 2, 6, 3, 7, 3, 6, 4, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0}*/
+ /*  p Tvard[2][1]@21 = {7, 2, 6, 3, 7, 3, 6, 4, 7, 4, 0 <repeats 11 times>} */
+ /* p Tvardk[1][1]@24 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 2, 7, 2, 6, 3, 7, 3, 6, 4, 7, 4, 0, 0}*/
+ /* p Tvardk[1][1]@22 = {0, 0, 0, 0, 0, 0, 0, 0, 6, 2, 7, 2, 6, 3, 7, 3, 6, 4, 7, 4, 0, 0} */
+ /* Tvard[1][1]@4={4,3,1,2}    V4*V3 V1*V2               */ /* Position in model of the ith prod without age */
  /* Tvardk[4][1]=4;Tvardk[4][2]=3;Tvardk[7][1]=1;Tvardk[7][2]=2 */ /* Variables of a prod at position in the model equation*/
  /* TvarF TvarF[1]=Tvar[6]=2,  TvarF[2]=Tvar[7]=7, TvarF[3]=Tvar[9]=1  ID of fixed covariates or product V2, V1*V2, V1 */
  /* TvarFind;  TvarFind[1]=6,  TvarFind[2]=7, TvarFind[3]=9 *//* Inverse V2(6) is first fixed (single or prod)  */
- Line 1622  int *TvarVQ; /* TvarVQ[1]=V5 in V5+V4+V3
+ Line 1689  int *TvarVQ; /* TvarVQ[1]=V5 in V5+V4+V3
  int *TvarVQind; /* TvarVQind[1]=1 in V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */ /* Only simple time varying quantitative variable */
  int *TvarVV; /* We count ncovvt time varying covariates (single or products without age) and put their name into TvarVV */
  int *TvarVVind; /* We count ncovvt time varying covariates (single or products without age) and put their name into TvarVV */
+ int *TvarVVA; /* We count ncovvt time varying covariates (single or products with age) and put their name into TvarVVA */
+ int *TvarVVAind; /* We count ncovvt time varying covariates (single or products without age) and put their name into TvarVV */
+ int *TvarAVVA; /* We count ALL ncovta time varying covariates (single or products with age) and put their name into TvarVVA */
+ int *TvarAVVAind; /* We count ALL ncovta time varying covariates (single or products without age) and put their name into TvarVV */
        /*#  ID           V1     V2          weight               birth   death   1st    s1      V3      V4      V5       2nd  s2 */
-       /* model V1+V3+age*V1+age*V3+V1*V3 */
+       /* model V1+V3+age*V1+age*V3+V1*V3 + V1*V3*age */
-       /*  Tvar={1, 3, 1, 3, 6}, the 6 comes from the fact that there are already V1, V2, V3, V4, V5 native covariates */
+       /*  Tvar={1, 3, 1, 3, 6, 6}, the 6 comes from the fact that there are already V1, V2, V3, V4, V5 native covariates */
-       /* TvarVV={3,1,3}, for V3 and then the product V1*V3 is decomposed into V1 and V3 */
+       /* TvarVV={3,1,3,1,3}, for V3 and then the product V1*V3 is decomposed into V1 and V3 */
-       /* TvarVVind={2,5,5}, for V3 and then the product V1*V3 is decomposed into V1 and V3 */
+       /* TvarVVind={2,5,5,6,6}, for V3 and then the product V1*V3 is decomposed into V1 and V3 and V1*V3*age into 6,6 */
  int *Tvarsel; /**< Selected covariates for output */
  double *Tvalsel; /**< Selected modality value of covariate for output */
- int *Typevar; /**< 0 for simple covariate (dummy, quantitative, fixed or varying), 1 for age product, 2 for  product */
+ int *Typevar; /**< 0 for simple covariate (dummy, quantitative, fixed or varying), 1 for age product, 2 for  product, 3 age*Vn*Vm */
  int *Fixed; /** Fixed[k] 0=fixed, 1 varying, 2 fixed with age product, 3 varying with age product */
  int *Dummy; /** Dummy[k] 0=dummy (0 1), 1 quantitative (single or product without age), 2 dummy with age product, 3 quant with age product */
  int *DummyV; /** Dummy[v] 0=dummy (0 1), 1 quantitative */
- Line 1766  char *trimbb(char *out, char *in)
+ Line 1837  char *trimbb(char *out, char *in)
    return s;
  }
+ char *trimbtab(char *out, char *in)
+ { /* Trim  blanks or tabs in line but keeps first blanks if line starts with blanks */
+   char *s;
+   s=out;
+   while (*in != '\0'){
+     while( (*in == ' ' || *in == '\t')){ /* && *(in+1) != '\0'){*/
+       in++;
+     }
+     *out++ = *in++;
+   }
+   *out='\0';
+   return s;
+ }
  /* char *substrchaine(char *out, char *in, char *chain) */
  /* { */
  /*   /\* Substract chain 'chain' from 'in', return and output 'out' *\/ */
- Line 1792  char *trimbb(char *out, char *in)
+ Line 1877  char *trimbb(char *out, char *in)
  char *substrchaine(char *out, char *in, char *chain)
  {
    /* Substract chain 'chain' from 'in', return and output 'out' */
-   /* in="V1+V1*age+age*age+V2", chain="age*age" */
+   /* in="V1+V1*age+age*age+V2", chain="+age*age" out="V1+V1*age+V2" */
    char *strloc;
-   strcpy (out, in);
+   strcpy (out, in);                   /* out="V1+V1*age+age*age+V2" */
-   strloc = strstr(out, chain); /* strloc points to out at age*age+V2 */
+   strloc = strstr(out, chain); /* strloc points to out at "+age*age+V2"  */
-   printf("Bef strloc=%s chain=%s out=%s \n", strloc, chain, out);
+   printf("Bef strloc=%s chain=%s out=%s \n", strloc, chain, out); /* strloc=+age*age+V2 chain="+age*age", out="V1+V1*age+age*age+V2" */
    if(strloc != NULL){
-     /* will affect out */ /* strloc+strlenc(chain)=+V2 */ /* Will also work in Unicode */
+     /* will affect out */ /* strloc+strlen(chain)=|+V2 = "V1+V1*age+age*age|+V2" */ /* Will also work in Unicodek */
-     memmove(strloc,strloc+strlen(chain), strlen(strloc+strlen(chain))+1);
+     memmove(strloc,strloc+strlen(chain), strlen(strloc+strlen(chain))+1); /* move number of bytes corresponding to the length of "+V2" which is 3, plus one is 4 (including the null)*/
-     /* strcpy (strloc, strloc +strlen(chain));*/
+     /* equivalent to strcpy (strloc, strloc +strlen(chain)) if no overlap; Copies from "+V2" to V1+V1*age+ */
    }
-   printf("Aft strloc=%s chain=%s in=%s out=%s \n", strloc, chain, in, out);
+   printf("Aft strloc=%s chain=%s in=%s out=%s \n", strloc, chain, in, out);  /* strloc=+V2 chain="+age*age", in="V1+V1*age+age*age+V2", out="V1+V1*age+V2" */
    return out;
  }
- Line 1812  char *substrchaine(char *out, char *in,
+ Line 1897  char *substrchaine(char *out, char *in,
  char *cutl(char *blocc, char *alocc, char *in, char occ)
  {
    /* cuts string in into blocc and alocc where blocc ends before FIRST occurence of char 'occ'
-      and alocc starts after first occurence of char 'occ' : ex cutv(blocc,alocc,"abcdef2ghi2j",'2')
+      and alocc starts after first occurence of char 'occ' : ex cutl(blocc,alocc,"abcdef2ghi2j",'2')
       gives alocc="abcdef" and blocc="ghi2j".
       If occ is not found blocc is null and alocc is equal to in. Returns blocc
    */
- Line 1878  int nbocc(char *s, char occ)
+ Line 1963  int nbocc(char *s, char occ)
    return j;
  }
+ int nboccstr(char *textin, char *chain)
+ {
+   /* Counts the number of occurence of "chain"  in string textin */
+   /*  in="+V7*V4+age*V2+age*V3+age*V4"  chain="age" */
+   char *strloc;
+   int i,j=0;
+   i=0;
+   strloc=textin; /* strloc points to "^+V7*V4+age+..." in textin */
+   for(;;) {
+     strloc= strstr(strloc,chain); /* strloc points to first character of chain in textin if found. Example strloc points^ to "+V7*V4+^age" in textin  */
+     if(strloc != NULL){
+       strloc = strloc+strlen(chain); /* strloc points to "+V7*V4+age^" in textin */
+       j++;
+     }else
+       break;
+   }
+   return j;
+ }
  /* void cutv(char *u,char *v, char*t, char occ) */
  /* { */
  /*   /\* cuts string t into u and v where u ends before last occurence of char 'occ'  */
- Line 2526  void linmin(double p[], double xi[], int
+ Line 2633  void linmin(double p[], double xi[], int
    free_vector(pcom,1,n);
  }
+ /**** praxis gegen ****/
+ /* This has been tested by Visual C from Microsoft and works */
+ /* meaning tha valgrind could be wrong */
+ /*********************************************************************/
+ /*      f u n c t i o n     p r a x i s                              */
+ /*                                                                   */
+ /* praxis is a general purpose routine for the minimization of a     */
+ /* function in several variables. the algorithm used is a modifi-    */
+ /* cation of conjugate gradient search method by powell. the changes */
+ /* are due to r.p. brent, who gives an algol-w program, which served */
+ /* as a basis for this function.                                     */
+ /*                                                                   */
+ /* references:                                                       */
+ /*     - powell, m.j.d., 1964. an efficient method for finding       */
+ /*       the minimum of a function in several variables without      */
+ /*       calculating derivatives, computer journal, 7, 155-162       */
+ /*     - brent, r.p., 1973. algorithms for minimization without      */
+ /*       derivatives, prentice hall, englewood cliffs.               */
+ /*                                                                   */
+ /*     problems, suggestions or improvements are always wellcome     */
+ /*                       karl gegenfurtner   07/08/87                */
+ /*                                           c - version             */
+ /*********************************************************************/
+ /*                                                                   */
+ /* usage: min = praxis(tol, macheps, h, n, prin, x, func)      */
+ /* macheps has been suppressed because it is replaced by DBL_EPSILON */
+ /* and if it was an argument of praxis (as it is in original brent)  */
+ /* it should be declared external */
+ /* usage: min = praxis(tol, h, n, prin, x, func)      */
+ /* was    min = praxis(fun, x, n);                                   */
+ /*                                                                   */
+ /*  fun        the function to be minimized. fun is called from      */
+ /*             praxis with x and n as arguments                      */
+ /*  x          a double array containing the initial guesses for     */
+ /*             the minimum, which will contain the solution on       */
+ /*             return                                                */
+ /*  n          an integer specifying the number of unknown           */
+ /*             parameters                                            */
+ /*  min        praxis returns the least calculated value of fun      */
+ /*                                                                   */
+ /* some additional global variables control some more aspects of     */
+ /* the inner workings of praxis. setting them is optional, they      */
+ /* are all set to some reasonable default values given below.        */
+ /*                                                                   */
+ /*   prin      controls the printed output from the routine.         */
+ /*             0 -> no output                                        */
+ /*             1 -> print only starting and final values             */
+ /*             2 -> detailed map of the minimization process         */
+ /*             3 -> print also eigenvalues and vectors of the        */
+ /*                  search directions                                */
+ /*             the default value is 1                                */
+ /*  tol        is the tolerance allowed for the precision of the     */
+ /*             solution. praxis returns if the criterion             */
+ /*             2 * ||x[k]-x[k-1]|| <= sqrt(macheps) * ||x[k]|| + tol */
+ /*             is fulfilled more than ktm times.                     */
+ /*             the default value depends on the machine precision    */
+ /*  ktm        see just above. default is 1, and a value of 4 leads  */
+ /*             to a very(!) cautious stopping criterion.             */
+ /*  h0 or step       is a steplength parameter and should be set equal     */
+ /*             to the expected distance from the solution.           */
+ /*             exceptionally small or large values of step lead to   */
+ /*             slower convergence on the first few iterations        */
+ /*             the default value for step is 1.0                     */
+ /*  scbd       is a scaling parameter. 1.0 is the default and        */
+ /*             indicates no scaling. if the scales for the different */
+ /*             parameters are very different, scbd should be set to  */
+ /*             a value of about 10.0.                                */
+ /*  illc       should be set to true (1) if the problem is known to  */
+ /*             be ill-conditioned. the default is false (0). this    */
+ /*             variable is automatically set, when praxis finds      */
+ /*             the problem to be ill-conditioned during iterations.  */
+ /*  maxfun     is the maximum number of calls to fun allowed. praxis */
+ /*             will return after maxfun calls to fun even when the   */
+ /*             minimum is not yet found. the default value of 0      */
+ /*             indicates no limit on the number of calls.            */
+ /*             this return condition is only checked every n         */
+ /*             iterations.                                           */
+ /*                                                                   */
+ /*********************************************************************/
+ #include <math.h>
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <float.h> /* for DBL_EPSILON */
+ /* #include "machine.h" */
+ /* extern void minfit(int n, double eps, double tol, double **ab, double q[]); */
+ /* extern void minfit(int n, double eps, double tol, double ab[N][N], double q[]); */
+ /* control parameters */
+ /* control parameters */
+ #define SQREPSILON 1.0e-19
+ /* #define EPSILON 1.0e-8 */ /* in main */
+ double tol = SQREPSILON,
+        scbd = 1.0,
+        step = 1.0;
+ int    ktm = 1,
+        /* prin = 2, */
+        maxfun = 0,
+        illc = 0;
+ /* some global variables */
+ static int i, j, k, k2, nl, nf, kl, kt;
+ /* static double s; */
+ double sl, dn, dmin,
+        fx, f1, lds, ldt, sf, df,
+        qf1, qd0, qd1, qa, qb, qc,
+        m2, m4, small_windows, vsmall, large,
+        vlarge, ldfac, t2;
+ /* static double d[N], y[N], z[N], */
+ /*        q0[N], q1[N], v[N][N]; */
+ static double *d, *y, *z;
+ static double  *q0, *q1, **v;
+ double *tflin; /* used in flin: return (*fun)(tflin, n); */
+ double *e; /* used in minfit, don't konw how to free memory and thus made global */
+ /* static double s, sl, dn, dmin, */
+ /*        fx, f1, lds, ldt, sf, df, */
+ /*        qf1, qd0, qd1, qa, qb, qc, */
+ /*        m2, m4, small, vsmall, large,  */
+ /*        vlarge, ldfac, t2; */
+ /* static double d[N], y[N], z[N], */
+ /*        q0[N], q1[N], v[N][N]; */
+ /* these will be set by praxis to point to it's arguments */
+ static int prin; /* added */
+ static int n;
+ static double *x;
+ static double (*fun)();
+ /* static double (*fun)(double *x, int n); */
+ /* these will be set by praxis to the global control parameters */
+ /* static double h, macheps, t; */
+ extern double macheps;
+ static double h;
+ static double t;
+ static double
+ drandom()       /* return random no between 0 and 1 */
+ {
+    return (double)(rand()%(8192*2))/(double)(8192*2);
+ }
+ static void sort()              /* d and v in descending order */
+ {
+    int k, i, j;
+    double s;
+    for (i=1; i<=n-1; i++) {
+        k = i; s = d[i];
+        for (j=i+1; j<=n; j++) {
+            if (d[j] > s) {
+               k = j;
+               s = d[j];
+            }
+        }
+        if (k > i) {
+           d[k] = d[i];
+           d[i] = s;
+           for (j=1; j<=n; j++) {
+               s = v[j][i];
+               v[j][i] = v[j][k];
+               v[j][k] = s;
+           }
+        }
+    }
+ }
+ double randbrent ( int *naught )
+ {
+   double ran1, ran3[127], half;
+   int ran2, q, r, i, j;
+   int init=0; /* false */
+   double rr;
+   /* REAL*8 RAN1,RAN3(127),HALF */
+   /*     INTEGER RAN2,Q,R */
+   /*     LOGICAL INIT */
+   /*     DATA INIT/.FALSE./ */
+   /*     IF (INIT) GO TO 3 */
+   if(!init){
+ /*       R = MOD(NAUGHT,8190) + 1 *//* 1804289383 rand () */
+     r = *naught % 8190 + 1;/* printf(" naught r %d %d",*naught,r); */
+     ran2=127;
+     for(i=ran2; i>0; i--){
+ /*       RAN2 = 128 */
+ /*       DO 2 I=1,127 */
+       ran2 = ran2-1;
+ /*          RAN2 = RAN2 - 1 */
+       ran1 = -pow(2.0,55);
+ /*          RAN1 = -2.D0**55 */
+ /*          DO 1 J=1,7 */
+       for(j=1; j<=7;j++){
+ /*             R = MOD(1756*R,8191) */
+         r = (1756*r) % 8191;/* printf(" i=%d (1756*r)%8191=%d",j,r); */
+         q=r/32;
+ /*             Q = R/32 */
+ /* 1           RAN1 = (RAN1 + Q)*(1.0D0/256) */
+         ran1 =(ran1+q)*(1.0/256);
+       }
+ /* 2        RAN3(RAN2) = RAN1 */
+       ran3[ran2] = ran1; /* printf(" ran2=%d ran1=%.7g \n",ran2,ran1); */
+     }
+ /*       INIT = .TRUE. */
+     init=1;
+ /* 3     IF (RAN2.EQ.1) RAN2 = 128 */
+   }
+   if(ran2 == 0) ran2 = 126;
+   else ran2 = ran2 -1;
+   /* RAN2 = RAN2 - 1 */
+   /* RAN1 = RAN1 + RAN3(RAN2) */
+   ran1 = ran1 + ran3[ran2];/* printf("BIS ran2=%d ran1=%.7g \n",ran2,ran1);  */
+   half= 0.5;
+   /* HALF = .5D0 */
+   /* IF (RAN1.GE.0.D0) HALF = -HALF */
+   if(ran1 >= 0.) half =-half;
+   ran1 = ran1 +half;
+   ran3[ran2] = ran1;
+   rr= ran1+0.5;
+   /* RAN1 = RAN1 + HALF */
+   /*   RAN3(RAN2) = RAN1 */
+   /*   RANDOM = RAN1 + .5D0 */
+ /*   r = ( ( double ) ( *seed ) ) * 4.656612875E-10; */
+   return rr;
+ }
+ static void matprint(char *s, double **v, int m, int n)
+ /* char *s; */
+ /* double v[N][N]; */
+ {
+ #define INCX 8
+   int i;
+   int i2hi;
+   int ihi;
+   int ilo;
+   int i2lo;
+   int jlo=1;
+   int j;
+   int j2hi;
+   int jhi;
+   int j2lo;
+   ilo=1;
+   ihi=n;
+   jlo=1;
+   jhi=n;
+   printf ("\n" );
+   printf ("%s\n", s );
+   for ( j2lo = jlo; j2lo <= jhi; j2lo = j2lo + INCX )
+   {
+     j2hi = j2lo + INCX - 1;
+     if ( n < j2hi )
+     {
+       j2hi = n;
+     }
+     if ( jhi < j2hi )
+     {
+       j2hi = jhi;
+     }
+     /* fprintf ( ficlog, "\n" ); */
+     printf ("\n" );
+ /*
+   For each column J in the current range...
+   Write the header.
+ */
+     /* fprintf ( ficlog, "  Col:  "); */
+     printf ("Col:");
+     for ( j = j2lo; j <= j2hi; j++ )
+     {
+       /* fprintf ( ficlog, "  %7d     ", j - 1 ); */
+       /* printf (" %9d      ", j - 1 ); */
+       printf (" %9d      ", j );
+     }
+     /* fprintf ( ficlog, "\n" ); */
+     /* fprintf ( ficlog, "  Row\n" ); */
+     /* fprintf ( ficlog, "\n" ); */
+     printf ("\n" );
+     printf ("  Row\n" );
+     printf ("\n" );
+ /*
+   Determine the range of the rows in this strip.
+ */
+     if ( 1 < ilo ){
+       i2lo = ilo;
+     }else{
+       i2lo = 1;
+     }
+     if ( m < ihi ){
+       i2hi = m;
+     }else{
+       i2hi = ihi;
+     }
+     for ( i = i2lo; i <= i2hi; i++ ){
+ /*
+   Print out (up to) 5 entries in row I, that lie in the current strip.
+ */
+       /* fprintf ( ficlog, "%5d:", i - 1 ); */
+       /* printf ("%5d:", i - 1 ); */
+       printf ("%5d:", i );
+       for ( j = j2lo; j <= j2hi; j++ )
+       {
+         /* fprintf ( ficlog, "  %14g", a[i-1+(j-1)*m] ); */
+         /* printf ("%14.7g  ", a[i-1+(j-1)*m] ); */
+            /* printf("%14.7f  ", v[i-1][j-1]); */
+            printf("%14.7f  ", v[i][j]);
+         /* fprintf ( stdout, "  %14g", a[i-1+(j-1)*m] ); */
+       }
+       /* fprintf ( ficlog, "\n" ); */
+       printf ("\n" );
+     }
+   }
+    /* printf("%s\n", s); */
+    /* for (k=0; k<n; k++) { */
+    /*     for (i=0; i<n; i++) { */
+    /*         /\* printf("%20.10e ", v[k][i]); *\/ */
+    /*     } */
+    /*     printf("\n"); */
+    /* } */
+ #undef INCX
+ }
+ void vecprint(char *s, double *x, int n)
+ /* char *s; */
+ /* double x[N]; */
+ {
+    int i=0;
+    printf(" %s", s);
+    /* for (i=0; i<n; i++) */
+    for (i=1; i<=n; i++)
+      printf ("  %14.7g",  x[i] );
+      /* printf("  %8d: %14g\n", i, x[i]); */
+    printf ("\n" );
+ }
+ static void print()             /* print a line of traces */
+ {
+    printf("\n");
+    /* printf("... chi square reduced to ... %20.10e\n", fx); */
+    /* printf("... after %u function calls ...\n", nf); */
+    /* printf("... including %u linear searches ...\n", nl); */
+    printf("%10d    %10d%14.7g",nl, nf, fx);
+    vecprint("... current values of x ...", x, n);
+ }
+ /* static void print2(int n, double *x, int prin, double fx, int nf, int nl) */ /* print a line of traces */
+ static void print2() /* print a line of traces */
+ {
+   int i; double fmin=0.;
+    /* printf("\n"); */
+    /* printf("... chi square reduced to ... %20.10e\n", fx); */
+    /* printf("... after %u function calls ...\n", nf); */
+    /* printf("... including %u linear searches ...\n", nl); */
+    /* printf("%10d    %10d%14.7g",nl, nf, fx); */
+   printf ( "\n" );
+   printf ( "  Linear searches      %d", nl );
+   /* printf ( "  Linear searches      %d\n", nl ); */
+   /* printf ( "  Function evaluations %d\n", nf ); */
+   /* printf ( "  Function value FX = %g\n", fx ); */
+   printf ( "  Function evaluations %d", nf );
+   printf ( "  Function value FX = %.12lf\n", fx );
+ #ifdef DEBUGPRAX
+    printf("n=%d prin=%d\n",n,prin);
+ #endif
+    if(fx <= fmin) printf(" UNDEFINED "); else  printf("%14.7g",log(fx-fmin));
+    if ( n <= 4 || 2 < prin )
+    {
+      /* for(i=1;i<=n;i++)printf("%14.7g",x[i-1]); */
+      for(i=1;i<=n;i++)printf("%14.7g",x[i]);
+      /* r8vec_print ( n, x, "  X:" ); */
+    }
+    printf("\n");
+  }
+ /* #ifdef MSDOS */
+ /* static double tflin[N]; */
+ /* #endif */
+ static double flin(double l, int j)
+ /* double l; */
+ {
+    int i;
+    /* #ifndef MSDOS */
+    /*    double tflin[N]; */
+    /* #endif    */
+    /* double *tflin; */ /* Be careful to put tflin on a vector n */
+    /* j is used from 0 to n-1 and can be -1 for parabolic search */
+    /* if (j != -1) {            /\* linear search *\/ */
+    if (j > 0) {         /* linear search */
+      /* for (i=0; i<n; i++){ */
+      for (i=1; i<=n; i++){
+           tflin[i] = x[i] + l *v[i][j];
+ #ifdef DEBUGPRAX
+           /* printf("     flin i=%14d t=%14.7f x=%14.7f l=%14.7f v[%d,%d]=%14.7f nf=%14d\n",i+1, tflin[i],x[i],l,i,j,v[i][j],nf); */
+           printf("     flin i=%14d t=%14.7f x=%14.7f l=%14.7f v[%d,%d]=%14.7f nf=%14d\n",i, tflin[i],x[i],l,i,j,v[i][j],nf);
+ #endif
+      }
+    }
+    else {                       /* search along parabolic space curve */
+       qa = l*(l-qd1)/(qd0*(qd0+qd1));
+       qb = (l+qd0)*(qd1-l)/(qd0*qd1);
+       qc = l*(l+qd0)/(qd1*(qd0+qd1));
+ #ifdef DEBUGPRAX
+       printf("     search along a parabolic space curve. j=%14d nf=%14d l=%14.7f qd0=%14.7f qd1=%14.7f\n",j,nf,l,qd0,qd1);
+ #endif
+       /* for (i=0; i<n; i++){ */
+       for (i=1; i<=n; i++){
+           tflin[i] = qa*q0[i]+qb*x[i]+qc*q1[i];
+ #ifdef DEBUGPRAX
+           /* printf("      parabole i=%14d t(i)=%14.7f q0=%14.7f x=%14.7f q1=%14.7f\n",i+1,tflin[i],q0[i],x[i],q1[i]); */
+           printf("      parabole i=%14d t(i)=%14.7e q0=%14.7e x=%14.7e q1=%14.7e\n",i,tflin[i],q0[i],x[i],q1[i]);
+ #endif
+       }
+    }
+    nf++;
+ #ifdef NR_SHIFT
+       return (*fun)((tflin-1), n);
+ #else
+      /* return (*fun)(tflin, n);*/
+       return (*fun)(tflin);
+ #endif
+ }
+ void minny(int j, int nits, double *d2, double *x1, double f1, int fk)
+ /* double *d2, *x1, f1; */
+ {
+ /* here j is from 0 to n-1 and can be -1 for parabolic search  */
+   /*      MINIMIZES F FROM X IN THE DIRECTION V(*,J) */
+           /*      UNLESS J<1, WHEN A QUADRATIC SEARCH IS DONE */
+           /*      IN THE PLANE DEFINED BY Q0, Q1 AND X. */
+           /*      D2 AN APPROXIMATION TO HALF F'' (OR ZERO), */
+           /*      X1 AN ESTIMATE OF DISTANCE TO MINIMUM, */
+           /*      RETURNED AS THE DISTANCE FOUND. */
+           /*       IF FK = TRUE THEN F1 IS FLIN(X1), OTHERWISE */
+           /*       X1 AND F1 ARE IGNORED ON ENTRY UNLESS FINAL */
+           /*       FX > F1. NITS CONTROLS THE NUMBER OF TIMES */
+           /*       AN ATTEMPT IS MADE TO HALVE THE INTERVAL. */
+           /* SIDE EFFECTS: USES AND ALTERS X, FX, NF, NL. */
+           /*       IF J < 1 USES VARIABLES Q... . */
+           /*       USES H, N, T, M2, M4, LDT, DMIN, MACHEPS; */
+    int k, i, dz;
+    double x2, xm, f0, f2, fm, d1, t2, sf1, sx1;
+    double s;
+    double macheps;
+    macheps=pow(16.0,-13.0);
+    sf1 = f1; sx1 = *x1;
+    k = 0; xm = 0.0; fm = f0 = fx; dz = *d2 < macheps;
+    /* h=1.0;*/ /* To be revised */
+ #ifdef DEBUGPRAX
+    /* printf("min macheps=%14g h=%14g step=%14g t=%14g fx=%14g\n",macheps,h, step,t, fx);  */
+    /* Where is fx coming from */
+    printf("   min macheps=%14g h=%14g  t=%14g fx=%.9lf dirj=%d\n",macheps, h, t, fx, j);
+    matprint("  min vectors:",v,n,n);
+ #endif
+    /* find step size */
+    s = 0.;
+    /* for (i=0; i<n; i++) s += x[i]*x[i]; */
+    for (i=1; i<=n; i++) s += x[i]*x[i];
+    s = sqrt(s);
+    if (dz)
+       t2 = m4*sqrt(fabs(fx)/dmin + s*ldt) + m2*ldt;
+    else
+       t2 = m4*sqrt(fabs(fx)/(*d2) + s*ldt) + m2*ldt;
+    s = s*m4 + t;
+    if (dz && t2 > s) t2 = s;
+    if (t2 < small_windows) t2 = small_windows;
+    if (t2 > 0.01*h) t2 = 0.01 * h;
+    if (fk && f1 <= fm) {
+       xm = *x1;
+       fm = f1;
+    }
+ #ifdef DEBUGPRAX
+    printf("   additional flin X1=%14.7f t2=%14.7f *f1=%14.7f fm=%14.7f fk=%d\n",*x1,t2,f1,fm,fk);
+ #endif
+    if (!fk || fabs(*x1) < t2) {
+      *x1 = (*x1 >= 0 ? t2 : -t2);
+       /* *x1 = (*x1 > 0 ? t2 : -t2); */ /* kind of error */
+ #ifdef DEBUGPRAX
+      printf("    additional flin X1=%16.10e dirj=%d fk=%d\n",*x1, j, fk);
+ #endif
+       f1 = flin(*x1, j);
+ #ifdef DEBUGPRAX
+     printf("    after flin f1=%18.12e dirj=%d fk=%d\n",f1, j,fk);
+ #endif
+    }
+    if (f1 <= fm) {
+       xm = *x1;
+       fm = f1;
+    }
+ L0: /*L0 loop or next */
+ /*
+   Evaluate FLIN at another point and estimate the second derivative.
+ */
+    if (dz) {
+       x2 = (f0 < f1 ? -(*x1) : 2*(*x1));
+ #ifdef DEBUGPRAX
+       printf("     additional second flin x2=%14.8e x1=%14.8e f0=%14.8e f1=%18.12e dirj=%d\n",x2,*x1,f0,f1,j);
+ #endif
+       f2 = flin(x2, j);
+ #ifdef DEBUGPRAX
+       printf("     additional second flin x2=%16.10e x1=%16.10e f1=%18.12e f0=%18.10e f2=%18.10e fm=%18.10e\n",x2, *x1, f1,f0,f2,fm);
+ #endif
+       if (f2 <= fm) {
+          xm = x2;
+          fm = f2;
+       }
+       /* d2 is the curvature or double difference f1 doesn't seem to be accurately computed */
+       *d2 = (x2*(f1-f0) - (*x1)*(f2-f0))/((*x1)*x2*((*x1)-x2));
+ #ifdef DEBUGPRAX
+       double d11,d12;
+       d11=(f1-f0)/(*x1);d12=(f2-f0)/x2;
+       printf(" d11=%18.12e d12=%18.12e d11-d12=%18.12e x1-x2=%18.12e (d11-d12)/(x2-(*x1))=%18.12e\n", d11 ,d12, d11-d12, x2-(*x1), (d11-d12)/(x2-(*x1)));
+       printf(" original computing f1=%18.12e *d2=%16.10e f0=%18.12e f1-f0=%16.10e f2-f0=%16.10e\n",f1,*d2,f0,f1-f0, f2-f0);
+       double ff1=7.783920622852e+04;
+       double f1mf0=9.0344736236e-05;
+       *d2 = (f1mf0)/ (*x1)/((*x1)-x2) - (f2-f0)/x2/((*x1)-x2);
+       /* *d2 = (ff1-f0)/ (*x1)/((*x1)-x2) - (f2-f0)/x2/((*x1)-x2); */
+       printf(" simpliff computing *d2=%16.10e f1mf0=%18.12e,f1=f0+f1mf0=%18.12e\n",*d2,f1mf0,f0+f1mf0);
+       *d2 = ((f1-f0)/ (*x1) - (f2-f0)/x2)/((*x1)-x2);
+       printf(" overlifi computing *d2=%16.10e\n",*d2);
+ #endif
+       *d2 = ((f1-f0)/ (*x1) - (f2-f0)/x2)/((*x1)-x2);
+    }
+ #ifdef DEBUGPRAX
+       printf("    additional second flin xm=%14.8e fm=%14.8e *d2=%14.8e\n",xm, fm,*d2);
+ #endif
+    /*
+      Estimate the first derivative at 0.
+    */
+    d1 = (f1-f0)/(*x1) - *x1**d2; dz = 1;
+    /*
+       Predict the minimum.
+     */
+    if (*d2 <= small_windows) {
+      x2 = (d1 < 0 ? h : -h);
+    }
+    else {
+       x2 = - 0.5*d1/(*d2);
+    }
+ #ifdef DEBUGPRAX
+     printf("   AT d1=%14.8e d2=%14.8e small=%14.8e dz=%d x1=%14.8e x2=%14.8e\n",d1,*d2,small_windows,dz,*x1,x2);
+ #endif
+     if (fabs(x2) > h)
+       x2 = (x2 > 0 ? h : -h);
+ L1:  /* L1 or try loop */
+ #ifdef DEBUGPRAX
+     printf("   AT predicted minimum flin x2=%14.8e x1=%14.8e K=%14d NITS=%14d dirj=%d\n",x2,*x1,k,nits,j);
+ #endif
+    f2 = flin(x2, j); /* x[i]+x2*v[i][j] */
+ #ifdef DEBUGPRAX
+    printf("   after flin f0=%14.8e f1=%14.8e f2=%14.8e fm=%14.8e\n",f0,f1,f2, fm);
+ #endif
+    if ((k < nits) && (f2 > f0)) {
+ #ifdef DEBUGPRAX
+      printf("  NO SUCCESS SO TRY AGAIN;\n");
+ #endif
+      k++;
+      if ((f0 < f1) && (*x1*x2 > 0.0))
+        goto L0; /* or next */
+      x2 *= 0.5;
+      goto L1;
+    }
+    nl++;
+ #ifdef DEBUGPRAX
+    printf(" bebeBE end of min x1=%14.8e x2=%14.8e f1=%14.8e f2=%14.8e f0=%14.8e fm=%14.8e d2=%14.8e\n",*x1, x2, f1, f2, f0, fm, *d2);
+ #endif
+    if (f2 > fm) x2 = xm; else fm = f2;
+    if (fabs(x2*(x2-*x1)) > small_windows) {
+       *d2 = (x2*(f1-f0) - *x1*(fm-f0))/(*x1*x2*(*x1-x2));
+    }
+    else {
+       if (k > 0) *d2 = 0;
+    }
+ #ifdef DEBUGPRAX
+    printf(" bebe end of min x1=%14.8e fx=%14.8e d2=%14.8e\n",*x1, fx, *d2);
+ #endif
+    if (*d2 <= small_windows) *d2 = small_windows;
+    *x1 = x2; fx = fm;
+    if (sf1 < fx) {
+       fx = sf1;
+       *x1 = sx1;
+    }
+   /*
+     Update X for linear search.
+   */
+ #ifdef DEBUGPRAX
+    printf("  end of min x1=%14.8e fx=%14.8e d2=%14.8e\n",*x1, fx, *d2);
+ #endif
+    /* if (j != -1) */
+    /*    for (i=0; i<n; i++) */
+    /*        x[i] += (*x1)*v[i][j]; */
+    if (j > 0)
+       for (i=1; i<=n; i++)
+           x[i] += (*x1)*v[i][j];
+ }
+ void quad()     /* look for a minimum along the curve q0, q1, q2        */
+ {
+    int i;
+    double l, s;
+    s = fx; fx = qf1; qf1 = s; qd1 = 0.0;
+    /* for (i=0; i<n; i++) { */
+    for (i=1; i<=n; i++) {
+        s = x[i]; l = q1[i]; x[i] = l; q1[i] = s;
+        qd1 = qd1 + (s-l)*(s-l);
+    }
+    s = 0.0; qd1 = sqrt(qd1); l = qd1;
+ #ifdef DEBUGPRAX
+   printf("  QUAD after sqrt qd1=%14.8e \n",qd1);
+ #endif
+    if (qd0>0.0 && qd1>0.0 &&nl>=3*n*n) {
+ #ifdef DEBUGPRAX
+      printf(" QUAD before min value=%14.8e \n",qf1);
+ #endif
+       /* min(-1, 2, &s, &l, qf1, 1); */
+       minny(0, 2, &s, &l, qf1, 1);
+       qa = l*(l-qd1)/(qd0*(qd0+qd1));
+       qb = (l+qd0)*(qd1-l)/(qd0*qd1);
+       qc = l*(l+qd0)/(qd1*(qd0+qd1));
+    }
+    else {
+       fx = qf1; qa = qb = 0.0; qc = 1.0;
+    }
+ #ifdef DEBUGPRAX
+   printf("after eventual min qd0=%14.8e qd1=%14.8e nl=%d\n",qd0, qd1,nl);
+ #endif
+    qd0 = qd1;
+    /* for (i=0; i<n; i++) { */
+    for (i=1; i<=n; i++) {
+        s = q0[i]; q0[i] = x[i];
+        x[i] = qa*s + qb*x[i] + qc*q1[i];
+    }
+ #ifdef DEBUGQUAD
+    vecprint ( " X after QUAD:" , x, n );
+ #endif
+ }
+ /* void minfit(int n, double eps, double tol, double ab[N][N], double q[]) */
+ void minfit(int n, double eps, double tol, double **ab, double q[])
+ /* int n; */
+ /* double eps, tol, ab[N][N], q[N]; */
+ {
+    int l, kt, l2, i, j, k;
+    double c, f, g, h, s, x, y, z;
+    /* double eps; */
+ /* #ifndef MSDOS */
+ /*    double e[N];              /\* plenty of stack on a vax *\/ */
+ /* #endif */
+    /* double *e; */
+    /* e=vector(0,n-1); /\* should be freed somewhere but gotos *\/ */
+    /* householder's reduction to bidiagonal form */
+    if(n==1){
+      /* q[1-1]=ab[1-1][1-1]; */
+      /* ab[1-1][1-1]=1.0; */
+      q[1]=ab[1][1];
+      ab[1][1]=1.0;
+      return; /* added from hardt */
+    }
+    /* eps=macheps; */ /* added */
+    x = g = 0.0;
+ #ifdef DEBUGPRAX
+    matprint (" HOUSE holder:", ab, n, n);
+ #endif
+    /* for (i=0; i<n; i++) {  /\* FOR I := 1 UNTIL N DO *\/ */
+    for (i=1; i<=n; i++) {  /* FOR I := 1 UNTIL N DO */
+      e[i] = g; s = 0.0; l = i+1;
+      /* for (j=i; j<n; j++)  /\* FOR J := I UNTIL N DO S := S*AB(J,I)**2; *\/ /\* not correct *\/ */
+      for (j=i; j<=n; j++)  /* FOR J := I UNTIL N DO S := S*AB(J,I)**2; */ /* not correct */
+        s += ab[j][i] * ab[j][i];
+ #ifdef DEBUGPRAXFIN
+      printf("i=%d s=%d %.7g tol=%.7g",i,s,tol);
+ #endif
+      if (s < tol) {
+        g = 0.0;
+      }
+      else {
+        /* f = ab[i][i]; */
+        f = ab[i][i];
+        if (f < 0.0)
+          g = sqrt(s);
+        else
+          g = -sqrt(s);
+        /* h = f*g - s; ab[i][i] = f - g; */
+        h = f*g - s; ab[i][i] = f - g;
+        /* for (j=l; j<n; j++) { */ /* FOR J := L UNTIL N DO */ /* wrong */
+        for (j=l; j<=n; j++) {
+          f = 0.0;
+          /* for (k=i; k<n; k++) /\* FOR K := I UNTIL N DO *\/ /\* wrong *\/ */
+          for (k=i; k<=n; k++) /* FOR K := I UNTIL N DO */
+            /* f += ab[k][i] * ab[k][j]; */
+            f += ab[k][i] * ab[k][j];
+          f /= h;
+          for (k=i; k<=n; k++) /* FOR K := I UNTIL N DO */
+            /* for (k=i; k<n; k++)/\* FOR K := I UNTIL N DO *\/ /\* wrong *\/ */
+            ab[k][j] += f * ab[k][i];
+          /* ab[k][j] += f * ab[k][i]; */
+ #ifdef DEBUGPRAX
+          printf("Holder J=%d F=%.7g",j,f);
+ #endif
+        }
+      } /* end s */
+      /* q[i] = g; s = 0.0; */
+      q[i] = g; s = 0.0;
+ #ifdef DEBUGPRAX
+      printf(" I Q=%d %.7g",i,q[i]);
+ #endif
+      /* if (i < n) */
+      /* if (i <= n)  /\* I is always lower or equal to n wasn't in golub reinsch*\/ */
+      /* for (j=l; j<n; j++) */
+      for (j=l; j<=n; j++)
+        s += ab[i][j] * ab[i][j];
+      /* s += ab[i][j] * ab[i][j]; */
+      if (s < tol) {
+        g = 0.0;
+      }
+      else {
+        if(i<n)
+          /* f = ab[i][i+1]; */ /* Brent golub overflow */
+          f = ab[i][i+1];
+        if (f < 0.0)
+          g = sqrt(s);
+        else
+          g = - sqrt(s);
+        h = f*g - s;
+        /* h = f*g - s; ab[i][i+1] = f - g; */ /* Overflow for i=n Error in Golub too but not Burkardt*/
+        /* for (j=l; j<n; j++) */
+        /*     e[j] = ab[i][j]/h; */
+        if(i<n){
+          ab[i][i+1] = f - g;
+          for (j=l; j<=n; j++)
+            e[j] = ab[i][j]/h;
+          /* for (j=l; j<n; j++) { */
+          for (j=l; j<=n; j++) {
+            s = 0.0;
+            /* for (k=l; k<n; k++) s += ab[j][k]*ab[i][k]; */
+            for (k=l; k<=n; k++) s += ab[j][k]*ab[i][k];
+            /* for (k=l; k<n; k++) ab[j][k] += s * e[k]; */
+            for (k=l; k<=n; k++) ab[j][k] += s * e[k];
+          } /* END J */
+        } /* END i <n */
+      } /* end s */
+        /* y = fabs(q[i]) + fabs(e[i]); */
+      y = fabs(q[i]) + fabs(e[i]);
+      if (y > x) x = y;
+ #ifdef DEBUGPRAX
+      printf(" I Y=%d %.7g",i,y);
+ #endif
+ #ifdef DEBUGPRAX
+      printf(" i=%d e(i) %.7g",i,e[i]);
+ #endif
+    } /* end i */
+    /*
+      Accumulation of right hand transformations */
+    /* for (i=n-1; i >= 0; i--) { */ /* FOR I := N STEP -1 UNTIL 1 DO */
+    /* We should avoid the overflow in Golub */
+    /* ab[n-1][n-1] = 1.0; */
+    /* g = e[n-1]; */
+    ab[n][n] = 1.0;
+    g = e[n];
+    l = n;
+    /* for (i=n; i >= 1; i--) { */
+    for (i=n-1; i >= 1; i--) { /* n-1 loops, different from brent and golub*/
+      if (g != 0.0) {
+        /* h = ab[i-1][i]*g; */
+        h = ab[i][i+1]*g;
+        for (j=l; j<=n; j++) ab[j][i] = ab[i][j] / h;
+        for (j=l; j<=n; j++) {
+          /* h = ab[i][i+1]*g; */
+          /* for (j=l; j<n; j++) ab[j][i] = ab[i][j] / h; */
+          /* for (j=l; j<n; j++) { */
+          s = 0.0;
+          /* for (k=l; k<n; k++) s += ab[i][k] * ab[k][j]; */
+          /* for (k=l; k<n; k++) ab[k][j] += s * ab[k][i]; */
+          for (k=l; k<=n; k++) s += ab[i][k] * ab[k][j];
+          for (k=l; k<=n; k++) ab[k][j] += s * ab[k][i];
+        }/* END J */
+      }/* END G */
+      /* for (j=l; j<n; j++) */
+      /*     ab[i][j] = ab[j][i] = 0.0; */
+      /* ab[i][i] = 1.0; g = e[i]; l = i; */
+      for (j=l; j<=n; j++)
+        ab[i][j] = ab[j][i] = 0.0;
+      ab[i][i] = 1.0; g = e[i]; l = i;
+    }/* END I */
+ #ifdef DEBUGPRAX
+    matprint (" HOUSE accumulation:",ab,n, n );
+ #endif
+    /* diagonalization to bidiagonal form */
+    eps *= x;
+    /* for (k=n-1; k>= 0; k--) { */
+    for (k=n; k>= 1; k--) {
+      kt = 0;
+ TestFsplitting:
+ #ifdef DEBUGPRAX
+      printf(" TestFsplitting: k=%d kt=%d\n",k,kt);
+      /* for(i=1;i<=n;i++)printf(" e(%d)=%.14f",i,e[i]);printf("\n"); */
+ #endif
+      kt = kt+1;
+ /* TestFsplitting: */
+      /* if (++kt > 30) { */
+      if (kt > 30) {
+        e[k] = 0.0;
+        fprintf(stderr, "\n+++ MINFIT - Fatal error\n");
+        fprintf ( stderr, "  The QR algorithm failed to converge.\n" );
+      }
+      /* for (l2=k; l2>=0; l2--) { */
+      for (l2=k; l2>=1; l2--) {
+        l = l2;
+ #ifdef DEBUGPRAX
+        printf(" l e(l)< eps %d %.7g %.7g ",l,e[l], eps);
+ #endif
+        /* if (fabs(e[l]) <= eps) */
+        if (fabs(e[l]) <= eps)
+          goto TestFconvergence;
+        /* if (fabs(q[l-1]) <= eps)*/ /* missing if ( 1 < l ){ *//* printf(" q(l-1)< eps %d %.7g %.7g ",l-1,q[l-2], eps); */
+        if (fabs(q[l-1]) <= eps)
+          break; /* goto Cancellation; */
+      }
+    Cancellation:
+ #ifdef DEBUGPRAX
+      printf(" Cancellation:\n");
+ #endif
+      c = 0.0; s = 1.0;
+      for (i=l; i<=k; i++) {
+        f = s * e[i]; e[i] *= c;
+        /* f = s * e[i]; e[i] *= c; */
+        if (fabs(f) <= eps)
+          goto TestFconvergence;
+        /* g = q[i]; */
+        g = q[i];
+        if (fabs(f) < fabs(g)) {
+          double fg = f/g;
+          h = fabs(g)*sqrt(1.0+fg*fg);
+        }
+        else {
+          double gf = g/f;
+          h = (f!=0.0 ? fabs(f)*sqrt(1.0+gf*gf) : 0.0);
+        }
+        /*    COMMENT: THE ABOVE REPLACES Q(I):=H:=LONGSQRT(G*G+F*F) */
+        /* WHICH MAY GIVE INCORRECT RESULTS IF THE */
+        /* SQUARES UNDERFLOW OR IF F = G = 0; */
+        /* q[i] = h; */
+        q[i] = h;
+        if (h == 0.0) { h = 1.0; g = 1.0; }
+        c = g/h; s = -f/h;
+      }
+ TestFconvergence:
+  #ifdef DEBUGPRAX
+      printf(" TestFconvergence: l=%d k=%d\n",l,k);
+ #endif
+      /* z = q[k]; */
+      z = q[k];
+      if (l == k)
+        goto Convergence;
+      /* shift from bottom 2x2 minor */
+      /* x = q[l]; y = q[k-l]; g = e[k-1]; h = e[k]; */ /* Error */
+      x = q[l]; y = q[k-1]; g = e[k-1]; h = e[k];
+      f = ((y-z)*(y+z) + (g-h)*(g+h)) / (2.0*h*y);
+      g = sqrt(f*f+1.0);
+      if (f <= 0.0)
+        f = ((x-z)*(x+z) + h*(y/(f-g)-h))/x;
+      else
+        f = ((x-z)*(x+z) + h*(y/(f+g)-h))/x;
+      /* next qr transformation */
+      s = c = 1.0;
+      for (i=l+1; i<=k; i++) {
+ #ifdef DEBUGPRAXQR
+        printf(" Before Mid TestFconvergence: l+1=%d i=%d k=%d h=%.6e e(i)=%14.8f e(i-1)=%14.8f\n",l+1,i,k, h, e[i],e[i-1]);
+ #endif
+        /* g = e[i]; y = q[i]; h = s*g; g *= c; */
+        g = e[i]; y = q[i]; h = s*g; g *= c;
+        if (fabs(f) < fabs(h)) {
+          double fh = f/h;
+          z = fabs(h) * sqrt(1.0 + fh*fh);
+        }
+        else {
+          double hf = h/f;
+          z = (f!=0.0 ? fabs(f)*sqrt(1.0+hf*hf) : 0.0);
+        }
+        /* e[i-1] = z; */
+        e[i-1] = z;
+ #ifdef DEBUGPRAXQR
+        printf(" Mid TestFconvergence: l+1=%d i=%d k=%d h=%.6e e(i)=%14.8f e(i-1)=%14.8f\n",l+1,i,k, h, e[i],e[i-1]);
+ #endif
+        if (z == 0.0)
+          f = z = 1.0;
+        c = f/z; s = h/z;
+        f = x*c + g*s; g = - x*s + g*c; h = y*s;
+        y *= c;
+        /* for (j=0; j<n; j++) { */
+        /*     x = ab[j][i-1]; z = ab[j][i]; */
+        /*     ab[j][i-1] = x*c + z*s; */
+        /*     ab[j][i] = - x*s + z*c; */
+        /* } */
+        for (j=1; j<=n; j++) {
+          x = ab[j][i-1]; z = ab[j][i];
+          ab[j][i-1] = x*c + z*s;
+          ab[j][i] = - x*s + z*c;
+        }
+        if (fabs(f) < fabs(h)) {
+          double fh = f/h;
+          z = fabs(h) * sqrt(1.0 + fh*fh);
+        }
+        else {
+          double hf = h/f;
+          z = (f!=0.0 ? fabs(f)*sqrt(1.0+hf*hf) : 0.0);
+        }
+ #ifdef DEBUGPRAXQR
+        printf(" qr transformation z f h=%.7g %.7g %.7g i=%d k=%d\n",z,f,h, i, k);
+ #endif
+        q[i-1] = z;
+        if (z == 0.0)
+          z = f = 1.0;
+        c = f/z; s = h/z;
+        f = c*g + s*y;  /* f can be very small */
+        x = - s*g + c*y;
+      }
+      /* e[l] = 0.0; e[k] = f; q[k] = x; */
+      e[l] = 0.0; e[k] = f; q[k] = x;
+ #ifdef DEBUGPRAXQR
+      printf(" aftermid loop l=%d k=%d e(l)=%7g e(k)=%.7g q(k)=%.7g x=%.7g\n",l,k,e[l],e[k],q[k],x);
+ #endif
+      goto TestFsplitting;
+    Convergence:
+ #ifdef DEBUGPRAX
+      printf(" Convergence:\n");
+ #endif
+      if (z < 0.0) {
+        /* q[k] = - z; */
+        /* for (j=0; j<n; j++) ab[j][k] = - ab[j][k]; */
+        q[k] = - z;
+        for (j=1; j<=n; j++) ab[j][k] = - ab[j][k];
+      }/* END Z */
+    }/* END K */
+ } /* END MINFIT */
+ double praxis(double tol, double macheps, double h0, int _n, int _prin, double *_x, double (*_fun)(double *_x))
+ /* double praxis(double tol, double macheps, double h0, int _n, int _prin, double *_x, double (*_fun)(double *_x, int _n)) */
+ /* double praxis(double (*_fun)(), double _x[], int _n) */
+ /* double (*_fun)(); */
+ /* double _x[N]; */
+ /* double (*_fun)(); */
+ /* double _x[N]; */
+ {
+    /* init global extern variables and parameters */
+    /* double *d, *y, *z, */
+    /*   *q0, *q1, **v; */
+    /* double *tflin; /\* used in flin: return (*fun)(tflin, n); *\/ */
+    /* double *e; /\* used in minfit, don't konw how to free memory and thus made global *\/ */
+   int seed; /* added */
+   int biter=0;
+   double r;
+   double randbrent( int (*));
+   double s, sf;
+    h = h0; /* step; */
+    t = tol;
+    scbd = 1.0;
+    illc = 0;
+    ktm = 1;
+    macheps = DBL_EPSILON;
+    /* prin=4; */
+ #ifdef DEBUGPRAX
+    printf("Praxis macheps=%14g h=%14g step=%14g tol=%14g\n",macheps,h, h0,tol);
+ #endif
+    n = _n;
+    x = _x;
+    prin = _prin;
+    fun = _fun;
+    d=vector(1, n);
+    y=vector(1, n);
+    z=vector(1, n);
+    q0=vector(1, n);
+    q1=vector(1, n);
+    e=vector(1, n);
+    tflin=vector(1, n);
+    v=matrix(1, n, 1, n);
+    for(i=1;i<=n;i++){d[i]=y[i]=z[i]=q0[0]=e[i]=tflin[i]=0.;}
+    small_windows = (macheps) * (macheps); vsmall = small_windows*small_windows;
+    large = 1.0/small_windows; vlarge = 1.0/vsmall;
+    m2 = sqrt(macheps); m4 = sqrt(m2);
+    seed = 123456789; /* added */
+    ldfac = (illc ? 0.1 : 0.01);
+    for(i=1;i<=n;i++) z[i]=0.; /* Was missing in Gegenfurtner as well as Brent's algol or fortran  */
+    nl = kt = 0; nf = 1;
+ #ifdef NR_SHIFT
+    fx = (*fun)((x-1), n);
+ #else
+    fx = (*fun)(x);
+ #endif
+    qf1 = fx;
+    t2 = small_windows + fabs(t); t = t2; dmin = small_windows;
+ #ifdef DEBUGPRAX
+    printf("praxis2 macheps=%14g h=%14g step=%14g small=%14g t=%14g\n",macheps,h, h0,small_windows, t);
+ #endif
+    if (h < 100.0*t) h = 100.0*t;
+ #ifdef DEBUGPRAX
+    printf("praxis3 macheps=%14g h=%14g step=%14g small=%14g t=%14g\n",macheps,h, h0,small_windows, t);
+ #endif
+    ldt = h;
+    /* for (i=0; i<n; i++) for (j=0; j<n; j++) */
+    for (i=1; i<=n; i++) for (j=1; j<=n; j++)
+        v[i][j] = (i == j ? 1.0 : 0.0);
+    d[1] = 0.0; qd0 = 0.0;
+    /* for (i=0; i<n; i++) q1[i] = x[i]; */
+    for (i=1; i<=n; i++) q1[i] = x[i];
+    if (prin > 1) {
+       printf("\n------------- enter function praxis -----------\n");
+       printf("... current parameter settings ...\n");
+       printf("... scaling ... %20.10e\n", scbd);
+       printf("...   tol   ... %20.10e\n", t);
+       printf("... maxstep ... %20.10e\n", h);
+       printf("...   illc  ... %20u\n", illc);
+       printf("...   ktm   ... %20u\n", ktm);
+       printf("... maxfun  ... %20u\n", maxfun);
+    }
+    if (prin) print2();
+ mloop:
+     biter++;  /* Added to count the loops */
+    /* sf = d[0]; */
+    /* s = d[0] = 0.0; */
+     printf("\n Big iteration %d \n",biter);
+     fprintf(ficlog,"\n Big iteration %d \n",biter);
+     sf = d[1];
+    s = d[1] = 0.0;
+    /* minimize along first direction V(*,1) */
+ #ifdef DEBUGPRAX
+    printf("  Minimize along the first direction V(*,1). illc=%d\n",illc);
+    /* fprintf(ficlog,"  Minimize along the first direction V(*,1).\n"); */
+ #endif
+ #ifdef DEBUGPRAX2
+    printf("praxis4 macheps=%14g h=%14g step=%14g small=%14g t=%14g\n",macheps,h, h0,small_windows, t);
+ #endif
+    /* min(0, 2, &d[0], &s, fx, 0); /\* mac heps not global *\/ */
+    minny(1, 2, &d[1], &s, fx, 0); /* mac heps not global */
+ #ifdef DEBUGPRAX
+    printf("praxis5 macheps=%14g h=%14g looks at sign of s=%14g fx=%14g\n",macheps,h, s,fx);
+ #endif
+    if (s <= 0.0)
+       /* for (i=0; i < n; i++) */
+       for (i=1; i <= n; i++)
+           v[i][1] = -v[i][1];
+    /* if ((sf <= (0.9 * d[0])) || ((0.9 * sf) >= d[0])) */
+    if ((sf <= (0.9 * d[1])) || ((0.9 * sf) >= d[1]))
+       /* for (i=1; i<n; i++) */
+       for (i=2; i<=n; i++)
+           d[i] = 0.0;
+    /* for (k=1; k<n; k++) { */
+    for (k=2; k<=n; k++) {
+     /*
+       The inner loop starts here.
+     */
+ #ifdef DEBUGPRAX
+       printf("      The inner loop  here from k=%d to n=%d.\n",k,n);
+       /* fprintf(ficlog,"      The inner loop  here from k=%d to n=%d.\n",k,n); */
+ #endif
+        /* for (i=0; i<n; i++) */
+        for (i=1; i<=n; i++)
+            y[i] = x[i];
+        sf = fx;
+ #ifdef DEBUGPRAX
+        printf(" illc=%d and kt=%d and ktm=%d\n", illc, kt, ktm);
+ #endif
+        illc = illc || (kt > 0);
+ next:
+        kl = k;
+        df = 0.0;
+        if (illc) {        /* random step to get off resolution valley */
+ #ifdef DEBUGPRAX
+           printf("  A random step follows, to avoid resolution valleys.\n");
+           matprint("  before rand, vectors:",v,n,n);
+ #endif
+           for (i=1; i<=n; i++) {
+ #ifdef NOBRENTRAND
+             r = drandom();
+ #else
+             seed=i;
+             /* seed=i+1; */
+ #ifdef DEBUGRAND
+             printf(" Random seed=%d, brent i=%d",seed,i); /* YYYY i=5 j=1 vji= -0.0001170073 */
+ #endif
+             r = randbrent ( &seed );
+ #endif
+ #ifdef DEBUGRAND
+             printf(" Random r=%.7g \n",r);
+ #endif
+             z[i] = (0.1 * ldt + t2 * pow(10.0,(double)kt)) * (r - 0.5);
+             /* z[i] = (0.1 * ldt + t2 * pow(10.0,(double)kt)) * (drandom() - 0.5); */
+             s = z[i];
+               for (j=1; j <= n; j++)
+                   x[j] += s * v[j][i];
+           }
+ #ifdef DEBUGRAND
+           matprint("  after rand, vectors:",v,n,n);
+ #endif
+ #ifdef NR_SHIFT
+           fx = (*fun)((x-1), n);
+ #else
+           fx = (*fun)(x, n);
+ #endif
+           /* fx = (*func) ( (x-1) ); *//* This for func which is computed from x[1] and not from x[0] xm1=(x-1)*/
+           nf++;
+        }
+        /* minimize along non-conjugate directions */
+ #ifdef DEBUGPRAX
+         printf(" Minimize along the 'non-conjugate' directions (dots printed) V(*,%d),...,V(*,%d).\n",k,n);
+         /* fprintf(ficlog," Minimize along the 'non-conjugate' directions  (dots printed) V(*,%d),...,V(*,%d).\n",k,n); */
+ #endif
+         /* for (k2=k; k2<n; k2++) {  /\* Be careful here k2 <=n ? *\/ */
+         for (k2=k; k2<=n; k2++) {  /* Be careful here k2 <=n ? */
+            sl = fx;
+            s = 0.0;
+ #ifdef DEBUGPRAX
+            printf(" Minimize along the 'NON-CONJUGATE' true direction k2=%14d fx=%14.7f\n",k2, fx);
+    matprint("  before min vectors:",v,n,n);
+ #endif
+            /* min(k2, 2, &d[k2], &s, fx, 0); */
+    /*     jsearch=k2-1; */
+    /* min(jsearch, 2, &d[jsearch], &s, fx, 0); */
+    minny(k2, 2, &d[k2], &s, fx, 0);
+ #ifdef DEBUGPRAX
+            printf(" . D(%d)=%14.7f d[k2]=%14.7f z[k2]=%14.7f illc=%14d fx=%14.7f\n",k2,d[k2],d[k2],z[k2],illc,fx);
+ #endif
+           if (illc) {
+               /* double szk = s + z[k2]; */
+               /* s = d[k2] * szk*szk; */
+               double szk = s + z[k2];
+               s = d[k2] * szk*szk;
+            }
+            else
+               s = sl - fx;
+            /* if (df < s) { */
+            if (df <= s) {
+               df = s;
+               kl = k2;
+ #ifdef DEBUGPRAX
+             printf(" df=%.7g and choose kl=%d \n",df,kl); /* UUUU */
+ #endif
+            }
+         } /* end loop k2 */
+         /*
+           If there was not much improvement on the first try, set
+           ILLC = true and start the inner loop again.
+         */
+ #ifdef DEBUGPRAX
+         printf(" If there was not much improvement on the first try, set ILLC = true and start the inner loop again. illc=%d\n",illc);
+         /* fprintf(ficlog,"  If there was not much improvement on the first try, set ILLC = true and start the inner loop again.\n"); */
+ #endif
+         if (!illc && (df < fabs(100.0 * (macheps) * fx))) {
+ #ifdef DEBUGPRAX
+           printf("\n NO SUCCESS because DF is small, starts inner loop with same K(=%d), fabs(  100.0 * machep(=%.10e) * fx(=%.9e) )=%.9e > df(=%.9e) break illc=%d\n", k, macheps, fx, fabs ( 100.0 * macheps * fx ), df, illc);
+ #endif
+           illc = 1;
+           goto next;
+         }
+ #ifdef DEBUGPRAX
+         printf("\n SUCCESS, BREAKS inner loop K(=%d) because DF is big, fabs(  100.0 * machep(=%.10e) * fx(=%.9e) )=%.9e <= df(=%.9e) break illc=%d\n", k, macheps, fx, fabs ( 100.0 * macheps * fx ), df, illc);
+ #endif
+        /* if ((k == 1) && (prin > 1)){ /\* be careful k=2 *\/ */
+        if ((k == 2) && (prin > 1)){ /* be careful k=2 */
+ #ifdef DEBUGPRAX
+         printf("  NEW D The second difference array d:\n" );
+         /* fprintf(ficlog, " NEW D The second difference array d:\n" ); */
+ #endif
+          vecprint(" NEW D The second difference array d:",d,n);
+        }
+        /* minimize along conjugate directions */
+        /*
+          Minimize along the "conjugate" directions V(*,1),...,V(*,K-1).
+        */
+ #ifdef DEBUGPRAX
+       printf("Minimize along the 'conjugate' directions V(*,1),...,V(*,K-1=%d).\n",k-1);
+       /* fprintf(ficlog,"Minimize along the 'conjugate' directions V(*,1),...,V(*,K-1=%d).\n",k-1); */
+ #endif
+       /* for (k2=0; k2<=k-1; k2++) { */
+       for (k2=1; k2<=k-1; k2++) {
+            s = 0.0;
+            /* min(k2-1, 2, &d[k2-1], &s, fx, 0); */
+            minny(k2, 2, &d[k2], &s, fx, 0);
+        }
+        f1 = fx;
+        fx = sf;
+        lds = 0.0;
+        /* for (i=0; i<n; i++) { */
+        for (i=1; i<=n; i++) {
+            sl = x[i];
+            x[i] = y[i];
+            y[i] = sl - y[i];
+            sl = y[i];
+            lds = lds + sl*sl;
+        }
+        lds = sqrt(lds);
+ #ifdef DEBUGPRAX
+        printf("Minimization done 'conjugate', shifted all points, computed lds=%.8f\n",lds);
+ #endif
+       /*
+         Discard direction V(*,kl).
+         If no random step was taken, V(*,KL) is the "non-conjugate"
+         direction along which the greatest improvement was made.
+       */
+        if (lds > small_windows) {
+ #ifdef DEBUGPRAX
+        printf("lds big enough to throw direction  V(*,kl=%d). If no random step was taken, V(*,KL) is the 'non-conjugate' direction along which the greatest improvement was made.\n",kl);
+          matprint("  before shift new conjugate vectors:",v,n,n);
+ #endif
+          for (i=kl-1; i>=k; i--) {
+            /* for (j=0; j < n; j++) */
+            for (j=1; j <= n; j++)
+              /* v[j][i+1] = v[j][i]; */ /* This is v[j][i+1]=v[j][i] i=kl-1 to k */
+              v[j][i+1] = v[j][i]; /* This is v[j][i+1]=v[j][i] i=kl-1 to k */
+            /* v[j][i+1] = v[j][i]; */
+            /* d[i+1] = d[i];*/  /* last  is d[k+1]= d[k] */
+            d[i+1] = d[i];  /* last  is d[k]= d[k-1] */
+          }
+ #ifdef DEBUGPRAX
+          matprint("  after shift new conjugate vectors:",v,n,n);
+ #endif   /* d[k] = 0.0; */
+          d[k] = 0.0;
+          for (i=1; i <= n; i++)
+            v[i][k] = y[i] / lds;
+          /* v[i][k] = y[i] / lds; */
+ #ifdef DEBUGPRAX
+          printf("Minimize along the new 'conjugate' direction V(*,k=%d), which is the normalized vector:  (new x) - (old x). d2=%14.7g lds=%.10f\n",k,d[k],lds);
+          /* fprintf(ficlog,"Minimize along the new 'conjugate' direction V(*,k=%d), which is the normalized vector:  (new x) - (old x).\n",k); */
+     matprint("  before min new conjugate vectors:",v,n,n);
+ #endif
+          /* min(k-1, 4, &d[k-1], &lds, f1, 1); */
+          minny(k, 4, &d[k], &lds, f1, 1);
+ #ifdef DEBUGPRAX
+          printf(" after min d(k)=%d %.7g lds=%14f\n",k,d[k],lds);
+    matprint("  after min vectors:",v,n,n);
+ #endif
+          if (lds <= 0.0) {
+            lds = -lds;
+ #ifdef DEBUGPRAX
+           printf(" lds changed sign lds=%.14f k=%d\n",lds,k);
+ #endif
+            /* for (i=0; i<n; i++) */
+            /*   v[i][k] = -v[i][k]; */
+            for (i=1; i<=n; i++)
+              v[i][k] = -v[i][k];
+          }
+        }
+        ldt = ldfac * ldt;
+        if (ldt < lds)
+           ldt = lds;
+        if (prin > 0){
+ #ifdef DEBUGPRAX
+         printf(" k=%d",k);
+         /* fprintf(ficlog," k=%d",k); */
+ #endif
+         print2();/* n, x, prin, fx, nf, nl ); */
+        }
+        t2 = 0.0;
+        /* for (i=0; i<n; i++) */
+        for (i=1; i<=n; i++)
+            t2 += x[i]*x[i];
+        t2 = m2 * sqrt(t2) + t;
+        /*
+         See whether the length of the step taken since starting the
+         inner loop exceeds half the tolerance.
+       */
+ #ifdef DEBUGPRAX
+        printf("See if step length exceeds half the tolerance.\n"); /* ZZZZZ */
+       /* fprintf(ficlog,"See if step length exceeds half the tolerance.\n"); */
+ #endif
+        if (ldt > (0.5 * t2))
+           kt = 0;
+        else
+           kt++;
+ #ifdef DEBUGPRAX
+        printf("if kt=%d >? ktm=%d gotoL2 loop\n",kt,ktm);
+ #endif
+        if (kt > ktm){
+          if ( 0 < prin ){
+            /* printf("\nr8vec_print\n X:\n"); */
+            /* fprintf(ficlog,"\nr8vec_print\n X:\n"); */
+            vecprint ("END  X:", x, n );
+          }
+            goto fret;
+        }
+ #ifdef DEBUGPRAX
+    matprint("  end of L2 loop vectors:",v,n,n);
+ #endif
+    }
+    /* printf("The inner loop ends here.\n"); */
+    /* fprintf(ficlog,"The inner loop ends here.\n"); */
+    /*
+      The inner loop ends here.
+      Try quadratic extrapolation in case we are in a curved valley.
+    */
+ #ifdef DEBUGPRAX
+    printf("Try QUAD ratic extrapolation in case we are in a curved valley.\n");
+ #endif
+    /*  try quadratic extrapolation in case    */
+    /*  we are stuck in a curved valley        */
+    quad();
+    dn = 0.0;
+    /* for (i=0; i<n; i++) { */
+    for (i=1; i<=n; i++) {
+        d[i] = 1.0 / sqrt(d[i]);
+        if (dn < d[i])
+           dn = d[i];
+    }
+    if (prin > 2)
+      matprint("  NEW DIRECTIONS vectors:",v,n,n);
+    /* for (j=0; j<n; j++) { */
+    for (j=1; j<=n; j++) {
+        s = d[j] / dn;
+        /* for (i=0; i < n; i++) */
+        for (i=1; i <= n; i++)
+            v[i][j] *= s;
+    }
+    if (scbd > 1.0) {       /* scale axis to reduce condition number */
+ #ifdef DEBUGPRAX
+      printf("Scale the axes to try to reduce the condition number.\n");
+ #endif
+      /* fprintf(ficlog,"Scale the axes to try to reduce the condition number.\n"); */
+       s = vlarge;
+       /* for (i=0; i<n; i++) { */
+       for (i=1; i<=n; i++) {
+           sl = 0.0;
+           /* for (j=0; j < n; j++) */
+           for (j=1; j <= n; j++)
+               sl += v[i][j]*v[i][j];
+           z[i] = sqrt(sl);
+           if (z[i] < m4)
+              z[i] = m4;
+           if (s > z[i])
+              s = z[i];
+       }
+       /* for (i=0; i<n; i++) { */
+       for (i=1; i<=n; i++) {
+           sl = s / z[i];
+           z[i] = 1.0 / sl;
+           if (z[i] > scbd) {
+              sl = 1.0 / scbd;
+              z[i] = scbd;
+           }
+       }
+    }
+    for (i=1; i<=n; i++)
+        /* for (j=0; j<=i-1; j++) { */
+        /* for (j=1; j<=i; j++) { */
+        for (j=1; j<=i-1; j++) {
+            s = v[i][j];
+            v[i][j] = v[j][i];
+            v[j][i] = s;
+        }
+ #ifdef DEBUGPRAX
+     printf(" Calculate a new set of orthogonal directions before repeating  the main loop.\n  Transpose V for MINFIT:...\n");
+ #endif
+       /*
+       MINFIT finds the singular value decomposition of V.
+       This gives the principal values and principal directions of the
+       approximating quadratic form without squaring the condition number.
+     */
+  #ifdef DEBUGPRAX
+     printf(" MINFIT finds the singular value decomposition of V. \n This gives the principal values and principal directions of the\n  approximating quadratic form without squaring the condition number...\n");
+ #endif
+    minfit(n, macheps, vsmall, v, d);
+     /* for(i=0; i<n;i++)printf(" %14.7g",d[i]); */
+     /* v is overwritten with R. */
+     /*
+       Unscale the axes.
+     */
+    if (scbd > 1.0) {
+ #ifdef DEBUGPRAX
+       printf(" Unscale the axes.\n");
+ #endif
+       /* for (i=0; i<n; i++) { */
+       for (i=1; i<=n; i++) {
+           s = z[i];
+           /* for (j=0; j<n; j++) */
+           for (j=1; j<=n; j++)
+               v[i][j] *= s;
+       }
+       /* for (i=0; i<n; i++) { */
+       for (i=1; i<=n; i++) {
+           s = 0.0;
+           /* for (j=0; j<n; j++) */
+           for (j=1; j<=n; j++)
+               s += v[j][i]*v[j][i];
+           s = sqrt(s);
+           d[i] *= s;
+           s = 1.0 / s;
+           /* for (j=0; j<n; j++) */
+           for (j=1; j<=n; j++)
+               v[j][i] *= s;
+       }
+    }
+    /* for (i=0; i<n; i++) { */
+    double dni; /* added for compatibility with buckhardt but not brent */
+    for (i=1; i<=n; i++) {
+      dni=dn*d[i]; /* added for compatibility with buckhardt but not brent */
+        if ((dn * d[i]) > large)
+           d[i] = vsmall;
+        else if ((dn * d[i]) < small_windows)
+           d[i] = vlarge;
+        else
+         d[i] = 1.0 / dni / dni; /* added for compatibility with buckhardt but not brent */
+           /* d[i] = pow(dn * d[i],-2.0); */
+    }
+ #ifdef DEBUGPRAX
+    vecprint ("\n Before sort Eigenvalues of a:",d,n );
+ #endif
+    sort();               /* the new eigenvalues and eigenvectors */
+ #ifdef DEBUGPRAX
+    vecprint( " After sort the eigenvalues ....\n", d, n);
+    matprint( " After sort the eigenvectors....\n", v, n,n);
+ #endif
+ #ifdef DEBUGPRAX
+     printf("  Determine the smallest eigenvalue.\n");
+ #endif
+    /* dmin = d[n-1]; */
+    dmin = d[n];
+    if (dmin < small_windows)
+       dmin = small_windows;
+     /*
+      The ratio of the smallest to largest eigenvalue determines whether
+      the system is ill conditioned.
+    */
+    /* illc = (m2 * d[0]) > dmin; */
+    illc = (m2 * d[1]) > dmin;
+ #ifdef DEBUGPRAX
+     printf("  The ratio of the smallest to largest eigenvalue determines whether\n  the system is ill conditioned=%d . dmin=%.10lf < m2=%.10lf * d[1]=%.10lf \n",illc, dmin,m2, d[1]);
+ #endif
+    if ((prin > 2) && (scbd > 1.0))
+       vecprint("\n The scale factors:",z,n);
+    if (prin > 2)
+       vecprint("  Principal values (EIGEN VALUES OF A) of the quadratic form:",d,n);
+    if (prin > 2)
+      matprint("  The principal axes (EIGEN VECTORS OF A:",v,n, n);
+    if ((maxfun > 0) && (nf > maxfun)) {
+       if (prin)
+          printf("\n... maximum number of function calls reached ...\n");
+       goto fret;
+    }
+ #ifdef DEBUGPRAX
+    printf("Goto main loop\n");
+ #endif
+    goto mloop;   /* back to main loop */
+ fret:
+    if (prin > 0) {
+          vecprint("\n  X:", x, n);
+          /* printf("\n... ChiSq reduced to %20.10e ...\n", fx); */
+          /* printf("... after %20u function calls.\n", nf); */
+    }
+    free_vector(d, 1, n);
+    free_vector(y, 1, n);
+    free_vector(z, 1, n);
+    free_vector(q0, 1, n);
+    free_vector(q1, 1, n);
+    free_matrix(v, 1, n, 1, n);
+    /*   double *d, *y, *z, */
+    /* *q0, *q1, **v; */
+    free_vector(tflin, 1, n);
+    /* double *tflin; /\* used in flin: return (*fun)(tflin, n); *\/ */
+    free_vector(e, 1, n);
+    /* double *e; /\* used in minfit, don't konw how to free memory and thus made global *\/ */
+    return(fx);
+ }
+ /* end praxis gegen */
  /*************** powell ************************/
  /*
- Line 2557  void powell(double p[], double **xi, int
+ Line 4170  void powell(double p[], double **xi, int
    double fp,fptt;
    double *xits;
    int niterf, itmp;
+   int Bigter=0, nBigterf=1;
    pt=vector(1,n);
    ptt=vector(1,n);
    xit=vector(1,n);
- Line 2570  void powell(double p[], double **xi, int
+ Line 4184  void powell(double p[], double **xi, int
      ibig=0;
      del=0.0;
      rlast_time=rcurr_time;
+     rlast_btime=rcurr_time;
      /* (void) gettimeofday(&curr_time,&tzp); */
      rcurr_time = time(NULL);
      curr_time = *localtime(&rcurr_time);
      /* printf("\nPowell iter=%d -2*LL=%.12f gain=%.12f=%.3g %ld sec. %ld sec.",*iter,*fret, fp-*fret,fp-*fret, rcurr_time-rlast_time, rcurr_time-rstart_time);fflush(stdout); */
      /* fprintf(ficlog,"\nPowell iter=%d -2*LL=%.12f gain=%.12f=%.3g %ld sec. %ld sec.",*iter,*fret, fp-*fret,fp-*fret,rcurr_time-rlast_time, rcurr_time-rstart_time); fflush(ficlog); */
-     printf("\nPowell iter=%d -2*LL=%.12f gain=%.3lg %ld sec. %ld sec.",*iter,*fret,fp-*fret, rcurr_time-rlast_time, rcurr_time-rstart_time);fflush(stdout);
+     /* Bigter=(*iter - *iter % ncovmodel)/ncovmodel +1; /\* Big iteration, i.e on ncovmodel cycle *\/ */
-     fprintf(ficlog,"\nPowell iter=%d -2*LL=%.12f gain=%.3lg %ld sec. %ld sec.",*iter,*fret,fp-*fret,rcurr_time-rlast_time, rcurr_time-rstart_time); fflush(ficlog);
+     Bigter=(*iter - (*iter-1) % n)/n +1; /* Big iteration, i.e on ncovmodel cycle */
- /*     fprintf(ficrespow,"%d %.12f %ld",*iter,*fret,curr_time.tm_sec-start_time.tm_sec); */
+     printf("\nPowell iter=%d Big Iter=%d -2*LL=%.12f gain=%.3lg %ld sec. %ld sec.",*iter,Bigter,*fret,fp-*fret, rcurr_time-rlast_time, rcurr_time-rstart_time);fflush(stdout);
+     fprintf(ficlog,"\nPowell iter=%d Big Iter=%d -2*LL=%.12f gain=%.3lg %ld sec. %ld sec.",*iter,Bigter,*fret,fp-*fret,rcurr_time-rlast_time, rcurr_time-rstart_time); fflush(ficlog);
+     fprintf(ficrespow,"%d %d %.12f %d",*iter,Bigter, *fret,curr_time.tm_sec-start_time.tm_sec);
      fp=(*fret); /* From former iteration or initial value */
      for (i=1;i<=n;i++) {
        fprintf(ficrespow," %.12lf", p[i]);
- Line 2599  void powell(double p[], double **xi, int
+ Line 4216  void powell(double p[], double **xi, int
        }else if(Typevar[j]==2) {
          printf("  +    V%d*V%d ",Tvard[Tposprod[j]][1],Tvard[Tposprod[j]][2]);
          fprintf(ficlog,"  +    V%d*V%d ",Tvard[Tposprod[j]][1],Tvard[Tposprod[j]][2]);
+       }else if(Typevar[j]==3) {
+         printf("  +    V%d*V%d*age ",Tvard[Tposprod[j]][1],Tvard[Tposprod[j]][2]);
+         fprintf(ficlog,"  +    V%d*V%d*age ",Tvard[Tposprod[j]][1],Tvard[Tposprod[j]][2]);
        }
      }
      printf("\n");
- Line 2629  void powell(double p[], double **xi, int
+ Line 4249  void powell(double p[], double **xi, int
          strcurr[itmp-1]='\0';
        printf("\nConsidering the time needed for the last iteration #%d: %ld seconds,\n",*iter,rcurr_time-rlast_time);
        fprintf(ficlog,"\nConsidering the time needed for this last iteration #%d: %ld seconds,\n",*iter,rcurr_time-rlast_time);
-       for(niterf=10;niterf<=30;niterf+=10){
+       for(nBigterf=1;nBigterf<=31;nBigterf+=10){
+         niterf=nBigterf*ncovmodel;
+         /* rforecast_time=rcurr_time+(niterf-*iter)*(rcurr_time-rlast_time); */
          rforecast_time=rcurr_time+(niterf-*iter)*(rcurr_time-rlast_time);
          forecast_time = *localtime(&rforecast_time);
          strcpy(strfor,asctime(&forecast_time));
          itmp = strlen(strfor);
          if(strfor[itmp-1]=='\n')
            strfor[itmp-1]='\0';
-         printf("   - if your program needs %d iterations to converge, convergence will be \n   reached in %s i.e.\n   on %s (current time is %s);\n",niterf, asc_diff_time(rforecast_time-rcurr_time,tmpout),strfor,strcurr);
+         printf("   - if your program needs %d BIG iterations (%d iterations) to converge, convergence will be \n   reached in %s i.e.\n   on %s (current time is %s);\n",nBigterf, niterf, asc_diff_time(rforecast_time-rcurr_time,tmpout),strfor,strcurr);
-         fprintf(ficlog,"   - if your program needs %d iterations to converge, convergence will be \n   reached in %s i.e.\n   on %s (current time is %s);\n",niterf, asc_diff_time(rforecast_time-rcurr_time,tmpout),strfor,strcurr);
+         fprintf(ficlog,"   - if your program needs %d BIG iterations  (%d iterations) to converge, convergence will be \n   reached in %s i.e.\n   on %s (current time is %s);\n",nBigterf, niterf, asc_diff_time(rforecast_time-rcurr_time,tmpout),strfor,strcurr);
        }
      }
-     for (i=1;i<=n;i++) { /* For each direction i */
+     for (i=1;i<=n;i++) { /* For each direction i, maximisation after loading directions */
-       for (j=1;j<=n;j++) xit[j]=xi[j][i]; /* Directions stored from previous iteration with previous scales */
+       for (j=1;j<=n;j++) xit[j]=xi[j][i]; /* Directions stored from previous iteration with previous scales. xi is not changed but one dim xit  */
-       fptt=(*fret);
+       fptt=(*fret); /* Computes likelihood for parameters xit */
  #ifdef DEBUG
        printf("fret=%lf, %lf, %lf \n", *fret, *fret, *fret);
        fprintf(ficlog, "fret=%lf, %lf, %lf \n", *fret, *fret, *fret);
- Line 2650  void powell(double p[], double **xi, int
+ Line 4273  void powell(double p[], double **xi, int
        printf("%d",i);fflush(stdout); /* print direction (parameter) i */
        fprintf(ficlog,"%d",i);fflush(ficlog);
  #ifdef LINMINORIGINAL
-       linmin(p,xit,n,fret,func); /* Point p[n]. xit[n] has been loaded for direction i as input.*/
+       linmin(p,xit,n,fret,func); /* New point i minimizing in direction xit, i has coordinates p[j].*/
+       /* xit[j] gives the n coordinates of direction i as input.*/
+       /* *fret gives the maximum value on direction xit */
  #else
        linmin(p,xit,n,fret,func,&flat); /* Point p[n]. xit[n] has been loaded for direction i as input.*/
-                         flatdir[i]=flat; /* Function is vanishing in that direction i */
+       flatdir[i]=flat; /* Function is vanishing in that direction i */
  #endif
-                         /* Outputs are fret(new point p) p is updated and xit rescaled */
+       /* Outputs are fret(new point p) p is updated and xit rescaled */
        if (fabs(fptt-(*fret)) > del) { /* We are keeping the max gain on each of the n directions */
-                                 /* because that direction will be replaced unless the gain del is small */
+         /* because that direction will be replaced unless the gain del is small */
-                                 /* in comparison with the 'probable' gain, mu^2, with the last average direction. */
+         /* in comparison with the 'probable' gain, mu^2, with the last average direction. */
-                                 /* Unless the n directions are conjugate some gain in the determinant may be obtained */
+         /* Unless the n directions are conjugate some gain in the determinant may be obtained */
-                                 /* with the new direction. */
+         /* with the new direction. */
-                                 del=fabs(fptt-(*fret));
+         del=fabs(fptt-(*fret));
-                                 ibig=i;
+         ibig=i;
        }
  #ifdef DEBUG
        printf("%d %.12e",i,(*fret));
        fprintf(ficlog,"%d %.12e",i,(*fret));
        for (j=1;j<=n;j++) {
-                                 xits[j]=FMAX(fabs(p[j]-pt[j]),1.e-5);
+         xits[j]=FMAX(fabs(p[j]-pt[j]),1.e-5);
-                                 printf(" x(%d)=%.12e",j,xit[j]);
+         printf(" x(%d)=%.12e",j,xit[j]);
-                                 fprintf(ficlog," x(%d)=%.12e",j,xit[j]);
+         fprintf(ficlog," x(%d)=%.12e",j,xit[j]);
        }
        for(j=1;j<=n;j++) {
-                                 printf(" p(%d)=%.12e",j,p[j]);
+         printf(" p(%d)=%.12e",j,p[j]);
-                                 fprintf(ficlog," p(%d)=%.12e",j,p[j]);
+         fprintf(ficlog," p(%d)=%.12e",j,p[j]);
        }
        printf("\n");
        fprintf(ficlog,"\n");
  #endif
      } /* end loop on each direction i */
-     /* Convergence test will use last linmin estimation (fret) and compare former iteration (fp) */
+     /* Convergence test will use last linmin estimation (fret) and compare to former iteration (fp) */
      /* But p and xit have been updated at the end of linmin, *fret corresponds to new p, xit  */
      /* New value of last point Pn is not computed, P(n-1) */
      for(j=1;j<=n;j++) {
- Line 2735  void powell(double p[], double **xi, int
+ Line 4360  void powell(double p[], double **xi, int
        return;
      } /* enough precision */
      if (*iter == ITMAX*n) nrerror("powell exceeding maximum iterations.");
-     for (j=1;j<=n;j++) { /* Computes the extrapolated point P_0 + 2 (P_n-P_0) */
+     for (j=1;j<=n;j++) { /* Computes the extrapolated point and value f3, P_0 + 2 (P_n-P_0)=2Pn-P0 and xit is direction Pn-P0 */
        ptt[j]=2.0*p[j]-pt[j];
-       xit[j]=p[j]-pt[j];
+       xit[j]=p[j]-pt[j]; /* Coordinate j of last direction xi_n=P_n-P_0 */
-       pt[j]=p[j];
+ #ifdef DEBUG
-     }
+       printf("\n %d xit=%12.7g p=%12.7g pt=%12.7g ",j,xit[j],p[j],pt[j]);
+ #endif
+       pt[j]=p[j]; /* New P0 is Pn */
+     }
+ #ifdef DEBUG
+     printf("\n");
+ #endif
      fptt=(*func)(ptt); /* f_3 */
- #ifdef NODIRECTIONCHANGEDUNTILNITER  /* No change in drections until some iterations are done */
+ #ifdef NODIRECTIONCHANGEDUNTILNITER  /* No change in directions until some iterations are done */
                  if (*iter <=4) {
  #else
  #endif
- Line 2760  void powell(double p[], double **xi, int
+ Line 4391  void powell(double p[], double **xi, int
        /* t=2.0*(fp-2.0*(*fret)+fptt)*SQR(fp-(*fret)-del)-del*SQR(fp-fptt); */
        /*  Even if f3 <f1, directest can be negative and t >0 */
        /* mu² and del² are equal when f3=f1 */
-                         /* f3 < f1 : mu² < del <= lambda^2 both test are equivalent */
+       /* f3 < f1 : mu² < del <= lambda^2 both test are equivalent */
-                         /* f3 < f1 : mu² < lambda^2 < del then directtest is negative and powell t is positive */
+       /* f3 < f1 : mu² < lambda^2 < del then directtest is negative and powell t is positive */
-                         /* f3 > f1 : lambda² < mu^2 < del then t is negative and directest >0  */
+       /* f3 > f1 : lambda² < mu^2 < del then t is negative and directest >0  */
-                         /* f3 > f1 : lambda² < del < mu^2 then t is positive and directest >0  */
+       /* f3 > f1 : lambda² < del < mu^2 then t is positive and directest >0  */
  #ifdef NRCORIGINAL
        t=2.0*(fp-2.0*(*fret)+fptt)*SQR(fp-(*fret)-del)- del*SQR(fp-fptt); /* Original Numerical Recipes in C*/
  #else
- Line 2785  void powell(double p[], double **xi, int
+ Line 4416  void powell(double p[], double **xi, int
        if (t < 0.0) { /* Then we use it for new direction */
  #else
        if (directest*t < 0.0) { /* Contradiction between both tests */
-                                 printf("directest= %.12lf (if <0 we include P0 Pn as new direction), t= %.12lf, f1= %.12lf,f2= %.12lf,f3= %.12lf, del= %.12lf\n",directest, t, fp,(*fret),fptt,del);
+         printf("directest= %.12lf (if <0 we include P0 Pn as new direction), t= %.12lf, f1= %.12lf,f2= %.12lf,f3= %.12lf, del= %.12lf\n",directest, t, fp,(*fret),fptt,del);
          printf("f1-2f2+f3= %.12lf, f1-f2-del= %.12lf, f1-f3= %.12lf\n",fp-2.0*(*fret)+fptt, fp -(*fret) -del, fp-fptt);
          fprintf(ficlog,"directest= %.12lf (if directest<0 or t<0 we include P0 Pn as new direction), t= %.12lf, f1= %.12lf,f2= %.12lf,f3= %.12lf, del= %.12lf\n",directest, t, fp,(*fret),fptt, del);
          fprintf(ficlog,"f1-2f2+f3= %.12lf, f1-f2-del= %.12lf, f1-f3= %.12lf\n",fp-2.0*(*fret)+fptt, fp -(*fret) -del, fp-fptt);
- Line 2864  void powell(double p[], double **xi, int
+ Line 4495  void powell(double p[], double **xi, int
          fprintf(ficlog,"\n");
  #endif
        } /* end of t or directest negative */
+       printf(" Directest is positive, P_n-P_0 does not increase the conjugacy. n=%d\n",n);
+       fprintf(ficlog," Directest is positive, P_n-P_0 does not increase the conjugacy. n=%d\n",n);
  #ifdef POWELLNOF3INFF1TEST
  #else
        } /* end if (fptt < fp)  */
- Line 2938  void powell(double p[], double **xi, int
+ Line 4571  void powell(double p[], double **xi, int
       /* Model(2)  V1 + V2 + V3 + V8 + V7*V8 + V5*V6 + V8*age + V3*age + age*age */
       /* total number of covariates of the model nbocc(+)+1 = 8 excepting constant and age and age*age */
       for(k1=1;k1<=cptcovt;k1++){ /* loop on model equation (including products) */
-        if(Typevar[k1]==1){ /* A product with age */
+        if(Typevar[k1]==1 || Typevar[k1]==3){ /* A product with age */
           cov[2+nagesqr+k1]=precov[nres][k1]*cov[2];
         }else{
           cov[2+nagesqr+k1]=precov[nres][k1];
- Line 3072  void powell(double p[], double **xi, int
+ Line 4705  void powell(double p[], double **xi, int
      first++;
    }
-   /* Try to lower 'ftol', for example from 1.e-8 to 6.e-9.\n", ftolpl, (int)age, (int)delaymax, (int)agefin, ncvloop, (int)age-(int)agefin); */
+   /* Try to lower 'ftol', for example from 1.e-8 to 6.e-9.\n", ftolpl,
+    * (int)age, (int)delaymax, (int)agefin, ncvloop,
+    * (int)age-(int)agefin); */
    free_vector(min,1,nlstate);
    free_vector(max,1,nlstate);
    free_vector(meandiff,1,nlstate);
- Line 3107  void powell(double p[], double **xi, int
+ Line 4742  void powell(double p[], double **xi, int
    /*  0.51326036147820708, 0.48673963852179264} */
    /* If we start from prlim again, prlim tends to a constant matrix */
-   int i, ii,j,k, k1;
+   int i, ii,j, k1;
    int first=0;
    double *min, *max, *meandiff, maxmax,sumnew=0.;
    /* double **matprod2(); */ /* test */
- Line 3148  void powell(double p[], double **xi, int
+ Line 4783  void powell(double p[], double **xi, int
        cov[3]= agefin*agefin;;
      }
      for(k1=1;k1<=cptcovt;k1++){ /* loop on model equation (including products) */
-       if(Typevar[k1]==1){ /* A product with age */
+       if(Typevar[k1]==1 || Typevar[k1]==3){ /* A product with age */
          cov[2+nagesqr+k1]=precov[nres][k1]*cov[2];
        }else{
          cov[2+nagesqr+k1]=precov[nres][k1];
- Line 3374  double **pmij(double **ps, double *cov,
+ Line 5009  double **pmij(double **ps, double *cov,
    /* Computes the backward probability at age agefin, cov[2], and covariate combination 'ij'. In fact cov is already filled and x too.
     * Call to pmij(cov and x), call to cross prevalence, sums and inverses, left multiply, and returns in **ps as well as **bmij.
     */
-   int i, ii, j,k;
+   int ii, j;
-   double **out, **pmij();
+   double  **pmij();
    double sumnew=0.;
    double agefin;
    double k3=0.; /* constant of the w_x diagonal matrix (in order for B to sum to 1 even for death state) */
- Line 3589  double ***hpxij(double ***po, int nhstep
+ Line 5224  double ***hpxij(double ***po, int nhstep
       */
-   int i, j, d, h, k, k1;
+   int i, j, d, h, k1;
    double **out, cov[NCOVMAX+1];
    double **newm;
    double agexact;
-   double agebegin, ageend;
+   /*double agebegin, ageend;*/
    /* Hstepm could be zero and should return the unit matrix */
    for (i=1;i<=nlstate+ndeath;i++)
- Line 3615  double ***hpxij(double ***po, int nhstep
+ Line 5250  double ***hpxij(double ***po, int nhstep
        /* Model(2)  V1 + V2 + V3 + V8 + V7*V8 + V5*V6 + V8*age + V3*age + age*age */
        /* total number of covariates of the model nbocc(+)+1 = 8 excepting constant and age and age*age */
        for(k1=1;k1<=cptcovt;k1++){ /* loop on model equation (including products) */
-         if(Typevar[k1]==1){ /* A product with age */
+         if(Typevar[k1]==1 || Typevar[k1]==3){ /* A product with age */
            cov[2+nagesqr+k1]=precov[nres][k1]*cov[2];
          }else{
            cov[2+nagesqr+k1]=precov[nres][k1];
- Line 3770  double ***hbxij(double ***po, int nhstep
+ Line 5405  double ***hbxij(double ***po, int nhstep
       The addresss of po (p3mat allocated to the dimension of nhstepm) should be stored for output
    */
-   int i, j, d, h, k, k1;
+   int i, j, d, h, k1;
    double **out, cov[NCOVMAX+1], **bmij();
    double **newm, ***newmm;
    double agexact;
-   double agebegin, ageend;
+   /*double agebegin, ageend;*/
    double **oldm, **savm;
    newmm=po; /* To be saved */
- Line 3801  double ***hbxij(double ***po, int nhstep
+ Line 5436  double ***hbxij(double ***po, int nhstep
        }
        /** New code */
        for(k1=1;k1<=cptcovt;k1++){ /* loop on model equation (including products) */
-         if(Typevar[k1]==1){ /* A product with age */
+         if(Typevar[k1]==1 || Typevar[k1]==3){ /* A product with age */
            cov[2+nagesqr+k1]=precov[nres][k1]*cov[2];
          }else{
            cov[2+nagesqr+k1]=precov[nres][k1];
- Line 3944  double func( double *x)
+ Line 5579  double func( double *x)
        */
        ioffset=2+nagesqr ;
     /* Fixed */
-       for (kf=1; kf<=ncovf;kf++){ /* For each fixed covariate dummu or quant or prod */
+       for (kf=1; kf<=ncovf;kf++){ /* For each fixed covariate dummy or quant or prod */
          /* # V1=sex, V2=raedyrs Quant Fixed, State=livarnb4..livarnb11, V3=iadl4..iald11, V4=adlw4..adlw11, V5=r4bmi..r11bmi */
          /*             V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */
          /*  TvarF[1]=Tvar[6]=2,  TvarF[2]=Tvar[7]=7, TvarF[3]=Tvar[9]=1  ID of fixed covariates or product V2, V1*V2, V1 */
- Line 3973  double func( double *x)
+ Line 5608  double func( double *x)
          for(ncovv=1, iposold=0; ncovv <= ncovvt ; ncovv++){ /* Varying  covariates (single and product but no age )*/
            itv=TvarVV[ncovv]; /*  TvarVV={3, 1, 3} gives the name of each varying covariate */
            ipos=TvarVVind[ncovv]; /* TvarVVind={2, 5, 5] gives the position in the model of the ncovv th varying covariate*/
-           if(TvarFind[itv]==0){ /* Not a fixed covariate */
+           if(FixedV[itv]!=0){ /* Not a fixed covariate */
              cotvarv=cotvar[mw[mi][i]][TvarVV[ncovv]][i];  /* cotvar[wav][ncovcol+nqv+iv][i] */
            }else{ /* fixed covariate */
-             cotvarv=covar[Tvar[TvarFind[itv]]][i];
+             cotvarv=covar[itv][i];  /* Error: TvarFind gives the name, that is the true column of fixed covariates, but Tvar of the model */
            }
            if(ipos!=iposold){ /* Not a product or first of a product */
              cotvarvold=cotvarv;
- Line 3986  double func( double *x)
+ Line 5621  double func( double *x)
            iposold=ipos;
            cov[ioffset+ipos]=cotvarv;
          }
-         /* for(itv=1; itv <= ntveff; itv++){ /\* Varying dummy covariates (single??)*\/ */
-         /*   iv= Tvar[Tmodelind[ioffset-2-nagesqr-cptcovage+itv]]-ncovcol-nqv; /\* Counting the # varying covariate from 1 to ntveff *\/ */
-         /*   cov[ioffset+iv]=cotvar[mw[mi][i]][iv][i]; */
-         /*   k=ioffset-2-nagesqr-cptcovage+itv; /\* position in simple model *\/ */
-         /*   cov[ioffset+itv]=cotvar[mw[mi][i]][TmodelInvind[itv]][i]; */
-         /*   printf(" i=%d,mi=%d,itv=%d,TmodelInvind[itv]=%d,cotvar[mw[mi][i]][TmodelInvind[itv]][i]=%f\n", i, mi, itv, TmodelInvind[itv],cotvar[mw[mi][i]][TmodelInvind[itv]][i]); */
-         /* } */
-         /* for(iqtv=1; iqtv <= nqtveff; iqtv++){ /\* Varying quantitatives covariates *\/ */
-         /*   iv=TmodelInvQind[iqtv]; /\* Counting the # varying covariate from 1 to ntveff *\/ */
-         /*   /\* printf(" i=%d,mi=%d,iqtv=%d,TmodelInvQind[iqtv]=%d,cotqvar[mw[mi][i]][TmodelInvQind[iqtv]][i]=%f\n", i, mi, iqtv, TmodelInvQind[iqtv],cotqvar[mw[mi][i]][TmodelInvQind[iqtv]][i]); *\/ */
-         /*   cov[ioffset+ntveff+iqtv]=cotqvar[mw[mi][i]][TmodelInvQind[iqtv]][i]; */
-         /* } */
          /* for products of time varying to be done */
          for (ii=1;ii<=nlstate+ndeath;ii++)
            for (j=1;j<=nlstate+ndeath;j++){
- Line 4013  double func( double *x)
+ Line 5636  double func( double *x)
            cov[2]=agexact;
            if(nagesqr==1)
              cov[3]= agexact*agexact;  /* Should be changed here */
-           for (kk=1; kk<=cptcovage;kk++) {
+           /* for (kk=1; kk<=cptcovage;kk++) { */
-             if(!FixedV[Tvar[Tage[kk]]])
+           /*   if(!FixedV[Tvar[Tage[kk]]]) */
-               cov[Tage[kk]+2+nagesqr]=covar[Tvar[Tage[kk]]][i]*agexact; /* Tage[kk] gives the data-covariate associated with age */
+           /*     cov[Tage[kk]+2+nagesqr]=covar[Tvar[Tage[kk]]][i]*agexact; /\* Tage[kk] gives the data-covariate associated with age *\/ */
-             else
+           /*   else */
-               cov[Tage[kk]+2+nagesqr]=cotvar[mw[mi][i]][Tvar[Tage[kk]]][i]*agexact; /* because cotvar starts now at first ncovcol+nqv+ (1 to nqtv) */
+           /*     cov[Tage[kk]+2+nagesqr]=cotvar[mw[mi][i]][Tvar[Tage[kk]]][i]*agexact; /\* because cotvar starts now at first ncovcol+nqv+ (1 to nqtv) *\/  */
+           /* } */
+           for(ncovva=1, iposold=0; ncovva <= ncovta ; ncovva++){ /* Time varying  covariates with age including individual from products, product is computed dynamically */
+             itv=TvarAVVA[ncovva]; /*  TvarVV={3, 1, 3} gives the name of each varying covariate, exploding product Vn*Vm into Vn and then Vm  */
+             ipos=TvarAVVAind[ncovva]; /* TvarVVind={2, 5, 5] gives the position in the model of the ncovv th varying covariate*/
+             if(FixedV[itv]!=0){ /* Not a fixed covariate? Could be a fixed covariate of a product with a higher than ncovcol+nqv, itv */
+               cotvarv=cotvar[mw[mi][i]][TvarAVVA[ncovva]][i];  /* because cotvar starts now at first ncovcol+nqv+ntv+nqtv (1 to nqtv) */
+             }else{ /* fixed covariate */
+               cotvarv=covar[itv][i];  /* Error: TvarFind gives the name, that is the true column of fixed covariates, but Tvar of the model */
+             }
+             if(ipos!=iposold){ /* Not a product or first of a product */
+               cotvarvold=cotvarv;
+             }else{ /* A second product */
+               cotvarv=cotvarv*cotvarvold;
+             }
+             iposold=ipos;
+             cov[ioffset+ipos]=cotvarv*agexact;
+             /* For products */
            }
            out=matprod2(newm,oldm,1,nlstate+ndeath,1,nlstate+ndeath,
 ,nlstate+ndeath,pmij(pmmij,cov,ncovmodel,x,nlstate));
            savm=oldm;
- Line 4287  double func( double *x)
+ Line 5928  double func( double *x)
  double funcone( double *x)
  {
    /* Same as func but slower because of a lot of printf and if */
-   int i, ii, j, k, mi, d, kk, kf=0;
+   int i, ii, j, k, mi, d, kv=0, kf=0;
    int ioffset=0;
    int ipos=0,iposold=0,ncovv=0;
- Line 4323  double funcone( double *x)
+ Line 5964  double funcone( double *x)
      /* Fixed */
      /* for (k=1; k<=cptcovn;k++) cov[2+nagesqr+k]=covar[Tvar[k]][i]; */
      /* for (k=1; k<=ncoveff;k++){ /\* Simple and product fixed Dummy covariates without age* products *\/ */
-     for (kf=1; kf<=ncovf;kf++){ /* Simple and product fixed covariates without age* products *//* Missing values are set to -1 but should be dropped */
+     for (kf=1; kf<=ncovf;kf++){ /*  V2  +  V3  +  V4  Simple and product fixed covariates without age* products *//* Missing values are set to -1 but should be dropped */
        /* printf("Debug3 TvarFind[%d]=%d",kf, TvarFind[kf]); */
        /* printf(" Tvar[TvarFind[kf]]=%d", Tvar[TvarFind[kf]]); */
        /* printf(" i=%d covar[Tvar[TvarFind[kf]]][i]=%f\n",i,covar[Tvar[TvarFind[kf]]][i]); */
- Line 4379  double funcone( double *x)
+ Line 6020  double funcone( double *x)
        * TvarVVind           2     3                                7 7     8 8      9 9
        * TvarFind[k]     1   0     0     0         0        0        0       0        0
        */
-       for(ncovv=1, iposold=0; ncovv <= ncovvt ; ncovv++){ /* Varying  covariates (single and product but no age) including individual from products */
+       /* Other model ncovcol=5 nqv=0 ntv=3 nqtv=0 nlstate=3
-         itv=TvarVV[ncovv]; /*  TvarVV={3, 1, 3} gives the name of each varying covariate */
+        * V2 V3 V4 are fixed V6 V7 are timevarying so V8 and V5 are not in the model and product column will start at 9 Tvar[(v6*V2)6]=9
+         * FixedV[ncovcol+qv+ntv+nqtv]       V5
+         * 3           V1  V2     V3    V4   V5 V6     V7  V8 V3*V2 V7*V2  V6*V3 V7*V3 V6*V4 V7*V4
+         *             0   0      0      0    0  1      1   1  0, 0, 1,1,   1, 0, 1, 0, 1, 0, 1, 0}
+         * 3           0   0      0      0    0  1      1   1  0,     1      1    1      1    1}
+         * model=          V2  +  V3  +  V4  +  V6  +  V7  +  V6*V2  +  V7*V2  +  V6*V3  +  V7*V3  +  V6*V4  +  V7*V4
+         *                +age*V2 +age*V3 +age*V4 +age*V6 + age*V7
+         *                +age*V6*V2 + age*V6*V3 +age*V7*V3 + age*V6*V4 +age*V7*V4
+         * model2=          V2  +  V3  +  V4  +  V6  +  V7  +  V3*V2  +  V7*V2  +  V6*V3  +  V7*V3  +  V6*V4  +  V7*V4
+         *                +age*V2 +age*V3 +age*V4 +age*V6 + age*V7
+         *                +age*V3*V2 + age*V6*V3 +age*V7*V3 + age*V6*V4 +age*V7*V4
+         * model3=          V2  +  V3  +  V4  +  V6  +  V7  + age*V3*V2  +  V7*V2  +  V6*V3  +  V7*V3  +  V6*V4  +  V7*V4
+         *                +age*V2 +age*V3 +age*V4 +age*V6 + age*V7
+         *                +V3*V2 + age*V6*V3 +age*V7*V3 + age*V6*V4 +age*V7*V4
+         * kmodel           1     2      3      4      5        6         7         8         9        10        11
+         *                  12       13      14      15       16
+         *                    17        18         19        20         21
+         * Tvar[kmodel]     2     3      4      6      7        9        10        11        12        13        14
+         *                   2       3        4       6        7
+         *                     9         11          12        13         14
+         * cptcovage=5+5 total of covariates with age
+         * Tage[cptcovage] age*V2=12      13      14      15       16
+         *1                   17            18         19        20         21 gives the position in model of covariates associated with age
+         *3 Tage[cptcovage] age*V3*V2=6
+         *3                age*V2=12         13      14      15       16
+         *3                age*V6*V3=18      19    20   21
+         * Tvar[Tage[cptcovage]]    Tvar[12]=2      3      4       6         Tvar[16]=7(age*V7)
+         *     Tvar[17]age*V6*V2=9      Tvar[18]age*V6*V3=11  age*V7*V3=12         age*V6*V4=13        Tvar[21]age*V7*V4=14
+         * 2   Tvar[17]age*V3*V2=9      Tvar[18]age*V6*V3=11  age*V7*V3=12         age*V6*V4=13        Tvar[21]age*V7*V4=14
+         * 3 Tvar[Tage[cptcovage]]    Tvar[6]=9      Tvar[12]=2      3     4       6         Tvar[16]=7(age*V7)
+         * 3     Tvar[18]age*V6*V3=11  age*V7*V3=12         age*V6*V4=13        Tvar[21]age*V7*V4=14
+         * 3 Tage[cptcovage] age*V3*V2=6   age*V2=12 age*V3 13    14      15       16
+         *                    age*V6*V3=18         19        20         21 gives the position in model of covariates associated with age
+         * 3   Tvar[17]age*V3*V2=9      Tvar[18]age*V6*V3=11  age*V7*V3=12         age*V6*V4=13        Tvar[21]age*V7*V4=14
+         * Tvar=                {2, 3, 4, 6, 7,
+         *                       9, 10, 11, 12, 13, 14,
+         *              Tvar[12]=2, 3, 4, 6, 7,
+         *              Tvar[17]=9, 11, 12, 13, 14}
+         * Typevar[1]@21 = {0, 0, 0, 0, 0,
+         *                  2, 2, 2, 2, 2, 2,
+         * 3                3, 2, 2, 2, 2, 2,
+         *                  1, 1, 1, 1, 1,
+         *                  3, 3, 3, 3, 3}
+         * 3                 2, 3, 3, 3, 3}
+         * p Tposprod[1]@21 {0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 1, 3, 4, 5, 6} Id of the prod at position k in the model
+         * p Tprod[1]@21 {6, 7, 8, 9, 10, 11, 0 <repeats 15 times>}
+         * 3 Tposprod[1]@21 {0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 1, 3, 4, 5, 6}
+         * 3 Tprod[1]@21 {17, 7, 8, 9, 10, 11, 0 <repeats 15 times>}
+         * cptcovprod=11 (6+5)
+         * FixedV[Tvar[Tage[cptcovage]]]]  FixedV[2]=0      FixedV[3]=0      0      1          (age*V7)Tvar[16]=1 FixedV[absolute] not [kmodel]
+         *   FixedV[Tvar[17]=FixedV[age*V6*V2]=FixedV[9]=1        1         1          1         1
+         * 3 FixedV[Tvar[17]=FixedV[age*V3*V2]=FixedV[9]=0        [11]=1         1          1         1
+         * FixedV[]          V1=0     V2=0   V3=0  v4=0    V5=0  V6=1    V7=1 v8=1  OK then model dependent
+         *                   9=1  [V7*V2]=[10]=1 11=1  12=1  13=1  14=1
+         * 3                 9=0  [V7*V2]=[10]=1 11=1  12=1  13=1  14=1
+         * cptcovdageprod=5  for gnuplot printing
+         * cptcovprodvage=6
+         * ncova=15           1        2       3       4       5
+         *                      6 7        8 9      10 11        12 13     14 15
+         * TvarA              2        3       4       6       7
+         *                      6 2        6 7       7 3          6 4       7 4
+         * TvaAind             12 12      13 13     14 14      15 15       16 16
+         * ncovf            1     2      3
+         *                                    V6       V7      V6*V2     V7*V2     V6*V3     V7*V3     V6*V4     V7*V4
+         * ncovvt=14                            1      2        3 4       5 6       7 8       9 10     11 12     13 14
+         * TvarVV[1]@14 = itv               {V6=6,     7, V6*V2=6, 2,     7, 2,     6, 3,     7, 3,     6, 4,     7, 4}
+         * TvarVVind[1]@14=                    {4,     5,       6, 6,     7, 7,     8, 8,      9, 9,   10, 10,   11, 11}
+         * 3 ncovvt=12                        V6       V7      V7*V2     V6*V3     V7*V3     V6*V4     V7*V4
+         * 3 TvarVV[1]@12 = itv                {6,     7, V7*V2=7, 2,     6, 3,     7, 3,     6, 4,     7, 4}
+         * 3                                    1      2        3  4      5  6      7  8      9 10     11 12
+         * TvarVVind[1]@12=         {V6 is in k=4,     5,  7,(4isV2)=7,   8, 8,      9, 9,   10,10,    11,11}TvarVVind[12]=k=11
+         * TvarV              6, 7, 9, 10, 11, 12, 13, 14
+         * 3 cptcovprodvage=6
+         * 3 ncovta=15    +age*V3*V2+age*V2+agev3+ageV4 +age*V6 + age*V7 + age*V6*V3 +age*V7*V3 + age*V6*V4 +age*V7*V4
+         * 3 TvarAVVA[1]@15= itva 3 2    2      3    4        6       7        6 3         7 3         6 4         7 4
+         * 3 ncovta             1 2      3      4    5        6       7        8 9       10 11       12 13        14 15
+         *?TvarAVVAind[1]@15= V3 is in k=2 1 1  2    3        4       5        4,2         5,2,      4,3           5 3}TvarVVAind[]
+         * TvarAVVAind[1]@15= V3 is in k=6 6 12  13   14      15      16       18 18       19,19,     20,20        21,21}TvarVVAind[]
+         * 3 ncovvta=10     +age*V6 + age*V7 + age*V6*V3 +age*V7*V3 + age*V6*V4 +age*V7*V4
+         * 3 we want to compute =cotvar[mw[mi][i]][TvarVVA[ncovva]][i] at position TvarVVAind[ncovva]
+         * 3 TvarVVA[1]@10= itva   6       7        6 3         7 3         6 4         7 4
+         * 3 ncovva                1       2        3 4         5 6         7 8         9 10
+         * TvarVVAind[1]@10= V6 is in k=4  5        8,8         9, 9,      10,10        11 11}TvarVVAind[]
+         * TvarVVAind[1]@10=       15       16     18,18        19,19,      20,20        21 21}TvarVVAind[]
+         * TvarVA              V3*V2=6 6 , 1, 2, 11, 12, 13, 14
+         * TvarFind[1]@14= {1,    2,     3,     0 <repeats 12 times>}
+         * Tvar[1]@21=     {2,    3,     4,    6,      7,      9,      10,        11,       12,      13,       14,
+         *                   2, 3, 4, 6, 7,
+         *                     6, 8, 9, 10, 11}
+         * TvarFind[itv]                        0      0       0
+         * FixedV[itv]                          1      1       1  0      1 0       1 0       1 0       0
+         *? FixedV[itv]                          1      1       1  0      1 0       1 0       1 0      1 0     1 0
+         * Tvar[TvarFind[ncovf]]=[1]=2 [2]=3 [4]=4
+         * Tvar[TvarFind[itv]]                [0]=?      ?ncovv 1 à ncovvt]
+         *   Not a fixed cotvar[mw][itv][i]     6       7      6  2      7, 2,     6, 3,     7, 3,     6, 4,     7, 4}
+         *   fixed covar[itv]                  [6]     [7]    [6][2]
+         */
+       for(ncovv=1, iposold=0; ncovv <= ncovvt ; ncovv++){ /*  V6       V7      V7*V2     V6*V3     V7*V3     V6*V4     V7*V4 Time varying  covariates (single and extended product but no age) including individual from products, product is computed dynamically */
+         itv=TvarVV[ncovv]; /*  TvarVV={3, 1, 3} gives the name of each varying covariate, or fixed covariate of a varying product after exploding product Vn*Vm into Vn and then Vm  */
          ipos=TvarVVind[ncovv]; /* TvarVVind={2, 5, 5] gives the position in the model of the ncovv th varying covariate*/
-         if(TvarFind[itv]==0){ /* Not a fixed covariate */
+         /* if(TvarFind[itv]==0){ /\* Not a fixed covariate? Could be a fixed covariate of a product with a higher than ncovcol+nqv, itv *\/ */
-           cotvarv=cotvar[mw[mi][i]][TvarVV[ncovv]][i];  /* because cotvar starts now at first ncovcol+nqv+ (1 to nqtv) */
+         if(FixedV[itv]!=0){ /* Not a fixed covariate? Could be a fixed covariate of a product with a higher than ncovcol+nqv, itv */
+           /* printf("DEBUG ncovv=%d, Varying TvarVV[ncovv]=%d\n",ncovv, TvarVV[ncovv]); */
+           cotvarv=cotvar[mw[mi][i]][TvarVV[ncovv]][i];  /* because cotvar starts now at first ncovcol+nqv+ntv+nqtv (1 to nqtv) */
+           /* printf("DEBUG Varying cov[ioffset+ipos=%d]=%g \n",ioffset+ipos,cotvarv); */
          }else{ /* fixed covariate */
-           cotvarv=covar[Tvar[TvarFind[itv]]][i];
+           /* cotvarv=covar[Tvar[TvarFind[itv]]][i];  /\* Error: TvarFind gives the name, that is the true column of fixed covariates, but Tvar of the model *\/ */
+           /* printf("DEBUG ncovv=%d, Fixed TvarVV[ncovv]=%d\n",ncovv, TvarVV[ncovv]); */
+           cotvarv=covar[itv][i];  /* Good: In V6*V3, 3 is fixed at position of the data */
+           /* printf("DEBUG Fixed cov[ioffset+ipos=%d]=%g \n",ioffset+ipos,cotvarv); */
          }
          if(ipos!=iposold){ /* Not a product or first of a product */
            cotvarvold=cotvarv;
- Line 4394  double funcone( double *x)
+ Line 6140  double funcone( double *x)
          }
          iposold=ipos;
          cov[ioffset+ipos]=cotvarv;
+         /* printf("DEBUG Product cov[ioffset+ipos=%d] \n",ioffset+ipos); */
          /* For products */
        }
        /* for(itv=1; itv <= ntveff; itv++){ /\* Varying dummy covariates single *\/ */
- Line 4432  double funcone( double *x)
+ Line 6179  double funcone( double *x)
          cov[2]=agexact;
          if(nagesqr==1)
            cov[3]= agexact*agexact;
-         for (kk=1; kk<=cptcovage;kk++) {
+         for(ncovva=1, iposold=0; ncovva <= ncovta ; ncovva++){ /* Time varying  covariates with age including individual from products, product is computed dynamically */
-           if(!FixedV[Tvar[Tage[kk]]])
+           itv=TvarAVVA[ncovva]; /*  TvarVV={3, 1, 3} gives the name of each varying covariate, exploding product Vn*Vm into Vn and then Vm  */
-             cov[Tage[kk]+2+nagesqr]=covar[Tvar[Tage[kk]]][i]*agexact;
+           ipos=TvarAVVAind[ncovva]; /* TvarVVind={2, 5, 5] gives the position in the model of the ncovv th varying covariate*/
-           else
+           /* if(TvarFind[itv]==0){ /\* Not a fixed covariate? Could be a fixed covariate of a product with a higher than ncovcol+nqv, itv *\/ */
-             cov[Tage[kk]+2+nagesqr]=cotvar[mw[mi][i]][Tvar[Tage[kk]]][i]*agexact; /* because cotvar starts now at first ncovcol+nqv+ (1 to nqtv) */
+           if(FixedV[itv]!=0){ /* Not a fixed covariate? Could be a fixed covariate of a product with a higher than ncovcol+nqv, itv */
+             /* printf("DEBUG  ncovva=%d, Varying TvarAVVA[ncovva]=%d\n", ncovva, TvarAVVA[ncovva]); */
+             cotvarv=cotvar[mw[mi][i]][TvarAVVA[ncovva]][i];  /* because cotvar starts now at first ncovcol+nqv+ntv+nqtv (1 to nqtv) */
+           }else{ /* fixed covariate */
+             /* cotvarv=covar[Tvar[TvarFind[itv]]][i];  /\* Error: TvarFind gives the name, that is the true column of fixed covariates, but Tvar of the model *\/ */
+             /* printf("DEBUG ncovva=%d, Fixed TvarAVVA[ncovva]=%d\n", ncovva, TvarAVVA[ncovva]); */
+             cotvarv=covar[itv][i];  /* Error: TvarFind gives the name, that is the true column of fixed covariates, but Tvar of the model */
+           }
+           if(ipos!=iposold){ /* Not a product or first of a product */
+             cotvarvold=cotvarv;
+           }else{ /* A second product */
+             /* printf("DEBUG * \n"); */
+             cotvarv=cotvarv*cotvarvold;
+           }
+           iposold=ipos;
+           /* printf("DEBUG Product cov[ioffset+ipos=%d] \n",ioffset+ipos); */
+           cov[ioffset+ipos]=cotvarv*agexact;
+           /* For products */
          }
          /* printf("i=%d,mi=%d,d=%d,mw[mi][i]=%d\n",i, mi,d,mw[mi][i]); */
          /* savm=pmij(pmmij,cov,ncovmodel,x,nlstate); */
          out=matprod2(newm,oldm,1,nlstate+ndeath,1,nlstate+ndeath,
- Line 4525  double funcone( double *x)
+ Line 6290  double funcone( double *x)
            }
            iposold=ipos;
          }
-         for (kk=1; kk<=cptcovage;kk++) {
+         /* for (kk=1; kk<=cptcovage;kk++) { */
-           if(!FixedV[Tvar[Tage[kk]]]){
+         /*   if(!FixedV[Tvar[Tage[kk]]]){ */
-             fprintf(ficresilk," %g*age",covar[Tvar[Tage[kk]]][i]);
+         /*     fprintf(ficresilk," %g*age",covar[Tvar[Tage[kk]]][i]); */
-             /* printf(" %g*age",covar[Tvar[Tage[kk]]][i]); */
+         /*     /\* printf(" %g*age",covar[Tvar[Tage[kk]]][i]); *\/ */
-           }else{
+         /*   }else{ */
-             fprintf(ficresilk," %g*age",cotvar[mw[mi][i]][Tvar[Tage[kk]]][i]);/* because cotvar starts now at first ncovcol+nqv+ (1 to nqtv) */
+         /*     fprintf(ficresilk," %g*age",cotvar[mw[mi][i]][Tvar[Tage[kk]]][i]);/\* because cotvar starts now at first ncovcol+nqv+ (1 to nqtv) *\/  */
-             /* printf(" %g*age",cotvar[mw[mi][i]][Tvar[Tage[kk]]][i]);/\* because cotvar starts now at first ncovcol+nqv+ (1 to nqtv) *\/  */
+         /*     /\* printf(" %g*age",cotvar[mw[mi][i]][Tvar[Tage[kk]]][i]);/\\* because cotvar starts now at first ncovcol+nqv+ (1 to nqtv) *\\/  *\/ */
+         /*   } */
+         /* } */
+         for(ncovva=1, iposold=0; ncovva <= ncovta ; ncovva++){ /* Time varying  covariates with age including individual from products, product is computed dynamically */
+           itv=TvarAVVA[ncovva]; /*  TvarVV={3, 1, 3} gives the name of each varying covariate, exploding product Vn*Vm into Vn and then Vm  */
+           ipos=TvarAVVAind[ncovva]; /* TvarVVind={2, 5, 5] gives the position in the model of the ncovv th varying covariate*/
+           /* if(TvarFind[itv]==0){ /\* Not a fixed covariate? Could be a fixed covariate of a product with a higher than ncovcol+nqv, itv *\/ */
+           if(FixedV[itv]!=0){ /* Not a fixed covariate? Could be a fixed covariate of a product with a higher than ncovcol+nqv, itv */
+             /* printf("DEBUG  ncovva=%d, Varying TvarAVVA[ncovva]=%d\n", ncovva, TvarAVVA[ncovva]); */
+             cotvarv=cotvar[mw[mi][i]][TvarAVVA[ncovva]][i];  /* because cotvar starts now at first ncovcol+nqv+ntv+nqtv (1 to nqtv) */
+           }else{ /* fixed covariate */
+             /* cotvarv=covar[Tvar[TvarFind[itv]]][i];  /\* Error: TvarFind gives the name, that is the true column of fixed covariates, but Tvar of the model *\/ */
+             /* printf("DEBUG ncovva=%d, Fixed TvarAVVA[ncovva]=%d\n", ncovva, TvarAVVA[ncovva]); */
+             cotvarv=covar[itv][i];  /* Error: TvarFind gives the name, that is the true column of fixed covariates, but Tvar of the model */
+           }
+           if(ipos!=iposold){ /* Not a product or first of a product */
+             cotvarvold=cotvarv;
+           }else{ /* A second product */
+             /* printf("DEBUG * \n"); */
+             cotvarv=cotvarv*cotvarvold;
            }
+           cotvarv=cotvarv*agexact;
+           fprintf(ficresilk," %g*age",cotvarv);
+           iposold=ipos;
+           /* printf("DEBUG Product cov[ioffset+ipos=%d] \n",ioffset+ipos); */
+           cov[ioffset+ipos]=cotvarv;
+           /* For products */
          }
          /* printf("\n"); */
          /* } /\*  End debugILK *\/ */
- Line 4626  void likelione(FILE *ficres,double p[],
+ Line 6416  void likelione(FILE *ficres,double p[],
        fprintf(fichtm,"<br>- Probability p<sub>%dj</sub> by origin %d and destination j. Dot's sizes are related to corresponding weight: <a href=\"%s-p%dj.png\">%s-p%dj.png</a><br>\n \
  <img src=\"%s-p%dj.png\">\n",k,k,subdirf2(optionfilefiname,"ILK_"),k,subdirf2(optionfilefiname,"ILK_"),k,subdirf2(optionfilefiname,"ILK_"),k);
        for(kf=1; kf <= ncovf; kf++){ /* For each simple dummy covariate of the model */
-         /* kvar=Tvar[TvarFind[kf]]; */ /* variable */
+          kvar=Tvar[TvarFind[kf]];  /* variable */
-         fprintf(fichtm,"<br>- Probability p<sub>%dj</sub> by origin %d and destination j with colored covariate V%d. Same dot size of all points but with a different color for transitions with dummy variable V%d=1 at beginning of transition (keeping former color for V%d=0): <a href=\"%s-p%dj.png\">%s-p%dj.png</a><br> \
+          fprintf(fichtm,"<br>- Probability p<sub>%dj</sub> by origin %d and destination j with colored covariate V%d. Same dot size of all points but with a different color for transitions with dummy variable V%d=1 at beginning of transition (keeping former color for V%d=0): ",k,k,Tvar[TvarFind[kf]],Tvar[TvarFind[kf]],Tvar[TvarFind[kf]]);
- <img src=\"%s-p%dj-%d.png\">",k,k,Tvar[TvarFind[kf]],Tvar[TvarFind[kf]],Tvar[TvarFind[kf]],subdirf2(optionfilefiname,"ILK_"),k,subdirf2(optionfilefiname,"ILK_"),k,subdirf2(optionfilefiname,"ILK_"),k,Tvar[TvarFind[kf]]);
+          fprintf(fichtm,"<a href=\"%s-p%dj-%d.png\">%s-p%dj-%d.png</a><br>",subdirf2(optionfilefiname,"ILK_"),k,kvar,subdirf2(optionfilefiname,"ILK_"),k,kvar);
+          fprintf(fichtm,"<img src=\"%s-p%dj-%d.png\">",subdirf2(optionfilefiname,"ILK_"),k,Tvar[TvarFind[kf]]);
        }
        for(ncovv=1, iposold=0; ncovv <= ncovvt ; ncovv++){ /* Loop on the time varying extended covariates (with extension of Vn*Vm */
          ipos=TvarVVind[ncovv]; /* TvarVVind={2, 5, 5] gives the position in the model of the ncovv th varying covariate */
- Line 4687  void likelione(FILE *ficres,double p[],
+ Line 6478  void likelione(FILE *ficres,double p[],
  void mlikeli(FILE *ficres,double p[], int npar, int ncovmodel, int nlstate, double ftol, double (*func)(double []))
  {
-   int i,j,k, jk, jkk=0, iter=0;
+   int i,j,  jkk=0, iter=0;
    double **xi;
-   double fret;
+   /*double fret;*/
-   double fretone; /* Only one call to likelihood */
+   /*double fretone;*/ /* Only one call to likelihood */
    /*  char filerespow[FILENAMELENGTH];*/
+   /*double * p1;*/ /* Shifted parameters from 0 instead of 1 */
  #ifdef NLOPT
    int creturn;
    nlopt_opt opt;
    /* double lb[9] = { -HUGE_VAL, -HUGE_VAL, -HUGE_VAL, -HUGE_VAL, -HUGE_VAL, -HUGE_VAL, -HUGE_VAL, -HUGE_VAL, -HUGE_VAL }; /\* lower bounds *\/ */
    double *lb;
    double minf; /* the minimum objective value, upon return */
-   double * p1; /* Shifted parameters from 0 instead of 1 */
    myfunc_data dinst, *d = &dinst;
  #endif
    xi=matrix(1,npar,1,npar);
-   for (i=1;i<=npar;i++)
+   for (i=1;i<=npar;i++)  /* Starting with canonical directions j=1,n xi[i=1,n][j] */
      for (j=1;j<=npar;j++)
        xi[i][j]=(i==j ? 1.0 : 0.0);
-   printf("Powell\n");  fprintf(ficlog,"Powell\n");
+   printf("Powell-prax\n");  fprintf(ficlog,"Powell-prax\n");
    strcpy(filerespow,"POW_");
    strcat(filerespow,fileres);
    if((ficrespow=fopen(filerespow,"w"))==NULL) {
- Line 4772  void mlikeli(FILE *ficres,double p[], in
+ Line 6564  void mlikeli(FILE *ficres,double p[], in
    }
    powell(p,xi,npar,ftol,&iter,&fret,flatdir,func);
  #else  /* FLATSUP */
-   powell(p,xi,npar,ftol,&iter,&fret,func);
+ /*  powell(p,xi,npar,ftol,&iter,&fret,func);*/
+ /*   praxis ( t0, h0, n, prin, x, beale_f ); */
+   int prin=1;
+   double h0=0.25;
+   double macheps;
+   double fmin;
+   macheps=pow(16.0,-13.0);
+ /* #include "praxis.h" */
+   /* Be careful that praxis start at x[0] and powell start at p[1] */
+    /* praxis ( ftol, h0, npar, prin, p, func ); */
+ /* p1= (p+1); */ /*  p *(p+1)@8 and p *(p1)@8 are equal p1[0]=p[1] */
+ printf("Praxis Gegenfurtner \n");
+ fprintf(ficlog, "Praxis  Gegenfurtner\n");fflush(ficlog);
+ /* praxis ( ftol, h0, npar, prin, p1, func ); */
+   /* fmin = praxis(1.e-5,macheps, h, n, prin, x, func); */
+   fmin = praxis(ftol,macheps, h0, npar, prin, p, func);
+ printf("End Praxis\n");
  #endif  /* FLATSUP */
  #ifdef LINMINORIGINAL
- Line 5034  double hessij( double x[], double **hess
+ Line 6842  double hessij( double x[], double **hess
        kmax=kmax+10;
      }
      if(kmax >=10 || firstime ==1){
+       /* What are the thetai and thetaj? thetai/ncovmodel thetai=(thetai-thetai%ncovmodel)/ncovmodel +thetai%ncovmodel=(line,pos)  */
        printf("Warning: directions %d-%d, you are not estimating the Hessian at the exact maximum likelihood; you could increase ftol=%.2e\n",thetai,thetaj, ftol);
        fprintf(ficlog,"Warning: directions %d-%d, you are not estimating the Hessian at the exact maximum likelihood; you could increase ftol=%.2e\n",thetai,thetaj, ftol);
        printf("%d %d k=%d, k1=%.12e k2=%.12e k3=%.12e k4=%.12e delti*k=%.12e deltj*k=%.12e, xi-de*k=%.12e xj-de*k=%.12e  res=%.12e k1234=%.12e,k1-2=%.12e,k3-4=%.12e\n",thetai,thetaj,k,k1,k2,k3,k4,delti[thetai]/k,delti[thetaj]/k,x[thetai]-delti[thetai]/k,x[thetaj]-delti[thetaj]/k, res,k1-k2-k3+k4,k1-k2,k3-k4);
- Line 5902  void prevalence(double ***probs, double
+ Line 7711  void prevalence(double ***probs, double
    int i, m, jk, j1, bool, z1,j, iv;
    int mi; /* Effective wave */
    int iage;
-   double agebegin, ageend;
+   double agebegin; /*, ageend;*/
    double **prop;
    double posprop;
- Line 6141  void  concatwav(int wav[], int **dh, int
+ Line 7950  void  concatwav(int wav[], int **dh, int
              if(j==0) j=1;  /* Survives at least one month after exam */
              else if(j<0){
                nberr++;
-               printf("Error! Negative delay (%d to death) between waves %d and %d of individual %ld at line %d who is aged %.1f with statuses from %d to %d\n ",j,mw[mi][i],mw[mi+1][i],num[i], i,agev[mw[mi][i]][i],s[mw[mi][i]][i] ,s[mw[mi+1][i]][i]);
+               printf("Error! Negative delay (%d to death) between waves %d and %d of individual %ld (around line %d) who is aged %.1f with statuses from %d to %d\n ",j,mw[mi][i],mw[mi+1][i],num[i], i,agev[mw[mi][i]][i],s[mw[mi][i]][i] ,s[mw[mi+1][i]][i]);
                j=1; /* Temporary Dangerous patch */
                printf("   We assumed that the date of interview was correct (and not the date of death) and postponed the death %d month(s) (one stepm) after the interview. You MUST fix the contradiction between dates.\n",stepm);
-               fprintf(ficlog,"Error! Negative delay (%d to death) between waves %d and %d of individual %ld at line %d who is aged %.1f with statuses from %d to %d\n ",j,mw[mi][i],mw[mi+1][i],num[i], i,agev[mw[mi][i]][i],s[mw[mi][i]][i] ,s[mw[mi+1][i]][i]);
+               fprintf(ficlog,"Error! Negative delay (%d to death) between waves %d and %d of individual %ld (around line %d) who is aged %.1f with statuses from %d to %d\n ",j,mw[mi][i],mw[mi+1][i],num[i], i,agev[mw[mi][i]][i],s[mw[mi][i]][i] ,s[mw[mi+1][i]][i]);
                fprintf(ficlog,"   We assumed that the date of interview was correct (and not the date of death) and postponed the death %d month(s) (one stepm) after the interview. You MUST fix the contradiction between dates.\n",stepm);
              }
              k=k+1;
- Line 6178  void  concatwav(int wav[], int **dh, int
+ Line 7987  void  concatwav(int wav[], int **dh, int
            /*printf("%d %lf %d %d %d\n", i,agev[mw[mi][i]][i],j,s[mw[mi][i]][i] ,s[mw[mi+1][i]][i]);*/
            if(j<0){
              nberr++;
-             printf("Error! Negative delay (%d) between waves %d and %d of individual %ld at line %d who is aged %.1f with statuses from %d to %d\n ",j,mw[mi][i],mw[mi+1][i],num[i], i,agev[mw[mi][i]][i],s[mw[mi][i]][i] ,s[mw[mi+1][i]][i]);
+             printf("Error! Negative delay (%d) between waves %d and %d of individual %ld (around line %d) who is aged %.1f with statuses from %d to %d\n ",j,mw[mi][i],mw[mi+1][i],num[i], i,agev[mw[mi][i]][i],s[mw[mi][i]][i] ,s[mw[mi+1][i]][i]);
-             fprintf(ficlog,"Error! Negative delay (%d) between waves %d and %d of individual %ld at line %d who is aged %.1f with statuses from %d to %d\n ",j,mw[mi][i],mw[mi+1][i],num[i], i,agev[mw[mi][i]][i],s[mw[mi][i]][i] ,s[mw[mi+1][i]][i]);
+             fprintf(ficlog,"Error! Negative delay (%d) between waves %d and %d of individual %ld (around line %d) who is aged %.1f with statuses from %d to %d\n ",j,mw[mi][i],mw[mi+1][i],num[i], i,agev[mw[mi][i]][i],s[mw[mi][i]][i] ,s[mw[mi+1][i]][i]);
            }
            sum=sum+j;
          }
- Line 6248  void  concatwav(int wav[], int **dh, int
+ Line 8057  void  concatwav(int wav[], int **dh, int
     for (k=1; k<=cptcovt; k++) { /* cptcovt: total number of covariates of the model (2) nbocc(+)+1 = 8 excepting constant and age and age*age */
       for (j=-1; (j < maxncov); j++) Ndum[j]=0;
       /* printf("Testing k=%d, cptcovt=%d\n",k, cptcovt); */
-      if(Dummy[k]==0 && Typevar[k] !=1 && Typevar[k] != 2){ /* Dummy covariate and not age product nor fixed product */
+      if(Dummy[k]==0 && Typevar[k] !=1 && Typevar[k] != 3  && Typevar[k] != 2){ /* Dummy covariate and not age product nor fixed product */
         switch(Fixed[k]) {
         case 0: /* Testing on fixed dummy covariate, simple or product of fixed */
           modmaxcovj=0;
- Line 6345  void  concatwav(int wav[], int **dh, int
+ Line 8154  void  concatwav(int wav[], int **dh, int
           break;
         } /* end switch */
       } /* end dummy test */
-      if(Dummy[k]==1 && Typevar[k] !=1 && Fixed ==0){ /* Fixed Quantitative covariate and not age product */
+      if(Dummy[k]==1 && Typevar[k] !=1 && Typevar[k] !=3 && Fixed ==0){ /* Fixed Quantitative covariate and not age product */
         for (i=1; i<=imx; i++) { /* Loop on individuals: reads the data file to get the maximum value of the  modality of this covariate Vj*/
           if(Tvar[k]<=0 || Tvar[k]>=NCOVMAX){
             printf("Error k=%d \n",k);
- Line 6811  void  concatwav(int wav[], int **dh, int
+ Line 8620  void  concatwav(int wav[], int **dh, int
     /*   fprintf(ficresprobmorprev," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][resultmodel[nres][j]]); */
     /* } */
     for (j=1; j<= cptcovs; j++){ /* For each selected (single) quantitative value */ /* To be done*/
+      /* fprintf(ficresprobmorprev," V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]); */
       fprintf(ficresprobmorprev," V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
     }
     /* for(j=1;j<=cptcoveff;j++)  */
- Line 7005  void  concatwav(int wav[], int **dh, int
+ Line 8815  void  concatwav(int wav[], int **dh, int
       }
       /* pptj is p.3 or p.j = trgradgp by cov by gradgp, variance of
-       * p.j overall mortality formula 49 but computed directly because
+       * p.j overall mortality formula 19 but computed directly because
        * we compute the grad (wix pijx) instead of grad (pijx),even if
        * wix is independent of theta.
        */
- Line 7370  void varprob(char optionfilefiname[], do
+ Line 9180  void varprob(char optionfilefiname[], do
     double ***varpij;
     strcpy(fileresprob,"PROB_");
-    strcat(fileresprob,fileres);
+    strcat(fileresprob,fileresu);
     if((ficresprob=fopen(fileresprob,"w"))==NULL) {
       printf("Problem with resultfile: %s\n", fileresprob);
       fprintf(ficlog,"Problem with resultfile: %s\n", fileresprob);
- Line 7527  To be simple, these graphs help to under
+ Line 9337  To be simple, these graphs help to under
           cov[3]= age*age;
         /* New code end of combination but for each resultline */
         for(k1=1;k1<=cptcovt;k1++){ /* loop on model equation (including products) */
-          if(Typevar[k1]==1){ /* A product with age */
+          if(Typevar[k1]==1 || Typevar[k1] ==3){ /* A product with age */
             cov[2+nagesqr+k1]=precov[nres][k1]*cov[2];
           }else{
             cov[2+nagesqr+k1]=precov[nres][k1];
- Line 7788  void printinghtml(char fileresu[], char
+ Line 9598  void printinghtml(char fileresu[], char
                    int popforecast, int mobilav, int prevfcast, int mobilavproj, int prevbcast, int estepm , \
                    double jprev1, double mprev1,double anprev1, double dateprev1, double dateprojd, double dateback1, \
                    double jprev2, double mprev2,double anprev2, double dateprev2, double dateprojf, double dateback2){
-   int jj1, k1, i1, cpt, k4, nres;
+   int jj1, k1, cpt, nres;
    /* In fact some results are already printed in fichtm which is open */
     fprintf(fichtm,"<ul><li><a href='#firstorder'>Result files (first order: no variance)</a>\n \
     <li><a href='#secondorder'>Result files (second order (variance)</a>\n \
- Line 7925  divided by h: <sub>h</sub>P<sub>ij</sub>
+ Line 9735  divided by h: <sub>h</sub>P<sub>ij</sub>
  <img src=\"%s_%d-3-%d.svg\">",stepm,subdirf2(optionfilefiname,"PE_"),k1,nres,subdirf2(optionfilefiname,"PE_"),k1,nres,subdirf2(optionfilefiname,"PE_"),k1,nres);
       /* Survival functions (period) in state j */
       for(cpt=1; cpt<=nlstate;cpt++){
-        fprintf(fichtm,"<br>\n- Survival functions in state %d. And probability to be observed in state %d being in state (1 to %d) at different ages. <a href=\"%s_%d-%d-%d.svg\">%s_%d-%d-%d.svg</a><br>", cpt, cpt, nlstate, subdirf2(optionfilefiname,"LIJ_"),cpt,k1,nres,subdirf2(optionfilefiname,"LIJ_"),cpt,k1,nres);
+        fprintf(fichtm,"<br>\n- Survival functions in state %d. And probability to be observed in state %d being in state (1 to %d) at different ages. Mean times spent in state (or Life Expectancy or Health Expectancy etc.) are the areas under each curve. <a href=\"%s_%d-%d-%d.svg\">%s_%d-%d-%d.svg</a><br>", cpt, cpt, nlstate, subdirf2(optionfilefiname,"LIJ_"),cpt,k1,nres,subdirf2(optionfilefiname,"LIJ_"),cpt,k1,nres);
         fprintf(fichtm," (data from text file  <a href=\"%s.txt\">%s.txt</a>)\n<br>",subdirf2(optionfilefiname,"PIJ_"),subdirf2(optionfilefiname,"PIJ_"));
         fprintf(fichtm,"<img src=\"%s_%d-%d-%d.svg\">",subdirf2(optionfilefiname,"LIJ_"),cpt,k1,nres);
       }
       /* State specific survival functions (period) */
       for(cpt=1; cpt<=nlstate;cpt++){
         fprintf(fichtm,"<br>\n- Survival functions in state %d and in any other live state (total).\
-  And probability to be observed in various states (up to %d) being in state %d at different ages.       \
+  And probability to be observed in various states (up to %d) being in state %d at different ages.  Mean times spent in state (or Life Expectancy or Health Expectancy etc.) are the areas under each curve. \
   <a href=\"%s_%d-%d-%d.svg\">%s_%d-%d-%d.svg</a><br> ", cpt, nlstate, cpt, subdirf2(optionfilefiname,"LIJT_"),cpt,k1,nres,subdirf2(optionfilefiname,"LIJT_"),cpt,k1,nres);
         fprintf(fichtm," (data from text file  <a href=\"%s.txt\">%s.txt</a>)\n<br>",subdirf2(optionfilefiname,"PIJ_"),subdirf2(optionfilefiname,"PIJ_"));
         fprintf(fichtm,"<img src=\"%s_%d-%d-%d.svg\">",subdirf2(optionfilefiname,"LIJT_"),cpt,k1,nres);
       }
       /* Period (forward stable) prevalence in each health state */
       for(cpt=1; cpt<=nlstate;cpt++){
-        fprintf(fichtm,"<br>\n- Convergence to period (stable) prevalence in state %d. Or probability for a person being in state (1 to %d) at different ages, to be in state %d some years after. <a href=\"%s_%d-%d-%d.svg\">%s_%d-%d-%d.svg</a><br>", cpt, nlstate, cpt, subdirf2(optionfilefiname,"P_"),cpt,k1,nres,subdirf2(optionfilefiname,"P_"),cpt,k1,nres);
+        fprintf(fichtm,"<br>\n- Convergence to period (stable) prevalence in state %d. Or probability for a person being in state (1 to %d) at different ages, to be alive in state %d some years after. <a href=\"%s_%d-%d-%d.svg\">%s_%d-%d-%d.svg</a><br>", cpt, nlstate, cpt, subdirf2(optionfilefiname,"P_"),cpt,k1,nres,subdirf2(optionfilefiname,"P_"),cpt,k1,nres);
         fprintf(fichtm," (data from text file  <a href=\"%s.txt\">%s.txt</a>)\n<br>",subdirf2(optionfilefiname,"PIJ_"),subdirf2(optionfilefiname,"PIJ_"));
        fprintf(fichtm,"<img src=\"%s_%d-%d-%d.svg\">" ,subdirf2(optionfilefiname,"P_"),cpt,k1,nres);
       }
- Line 7964  divided by h: <sub>h</sub>P<sub>ij</sub>
+ Line 9774  divided by h: <sub>h</sub>P<sub>ij</sub>
        /* Back projection of prevalence up to stable (mixed) back-prevalence in each health state */
         for(cpt=1; cpt<=nlstate;cpt++){
           fprintf(fichtm,"<br>\n- Back projection of cross-sectional prevalence (estimated with cases observed from %.1f to %.1f and mobil_average=%d), \
-  from year %.1f up to year %.1f (probably close to stable [mixed] back prevalence in state %d (randomness in cross-sectional prevalence is not taken into \
+  from year %.1f up to year %.1f (probably close to stable [mixed] back prevalence in state %d). Randomness in cross-sectional prevalence is not taken into \
-  account but can visually be appreciated). Or probability to have been in an state %d, knowing that the person was in either state (1 or %d) \
+  account but can visually be appreciated. Or probability to have been in an state %d, knowing that the person was in either state (1 or %d) \
  with weights corresponding to observed prevalence at different ages. <a href=\"%s_%d-%d-%d.svg\">%s_%d-%d-%d.svg</a>", dateprev1, dateprev2, mobilavproj, dateback1, dateback2, cpt, cpt, nlstate, subdirf2(optionfilefiname,"PROJB_"),cpt,k1,nres,subdirf2(optionfilefiname,"PROJB_"),cpt,k1,nres);
           fprintf(fichtm," (data from text file  <a href=\"%s.txt\">%s.txt</a>)\n<br>",subdirf2(optionfilefiname,"FB_"),subdirf2(optionfilefiname,"FB_"));
           fprintf(fichtm," <img src=\"%s_%d-%d-%d.svg\">", subdirf2(optionfilefiname,"PROJB_"),cpt,k1,nres);
- Line 8103  prevalence (with 95%% confidence interva
+ Line 9913  prevalence (with 95%% confidence interva
         fprintf(fichtm,"<img src=\"%s_%d-%d-%d.svg\">",subdirf2(optionfilefiname,"V_"), cpt,k1,nres);
       }
       fprintf(fichtm,"\n<br>- Total life expectancy by age and \
- health expectancies in each live states (1 to %d). If popbased=1 the smooth (due to the model) \
+ health expectancies in each live state (1 to %d) with confidence intervals \
+ on left y-scale as well as proportions of time spent in each live state \
+ (with confidence intervals) on right y-scale 0 to 100%%.\
+  If popbased=1 the smooth (due to the model)                            \
  true period expectancies (those weighted with period prevalences are also\
   drawn in addition to the population based expectancies computed using\
   observed and cahotic prevalences:  <a href=\"%s_%d-%d.svg\">%s_%d-%d.svg</a>",nlstate, subdirf2(optionfilefiname,"E_"),k1,nres,subdirf2(optionfilefiname,"E_"),k1,nres);
- Line 8118  true period expectancies (those weighted
+ Line 9931  true period expectancies (those weighted
  /******************* Gnuplot file **************/
  void printinggnuplot(char fileresu[], char optionfilefiname[], double ageminpar, double agemaxpar, double bage, double fage , int prevfcast, int prevbcast, char pathc[], double p[], int offyear, int offbyear){
-   char dirfileres[132],optfileres[132];
+   char dirfileres[256],optfileres[256];
-   char gplotcondition[132], gplotlabel[132];
+   char gplotcondition[256], gplotlabel[256];
    int cpt=0,k1=0,i=0,k=0,j=0,jk=0,k2=0,k3=0,k4=0,kf=0,kvar=0,kk=0,ipos=0,iposold=0,ij=0, ijp=0, l=0;
    int lv=0, vlv=0, kl=0;
    int ng=0;
- Line 8187  void printinggnuplot(char fileresu[], ch
+ Line 10000  void printinggnuplot(char fileresu[], ch
    fprintf(ficgp,"\nset ter pngcairo size 640, 480");
    /* if(debugILK==1){ */
    for(kf=1; kf <= ncovf; kf++){ /* For each simple dummy covariate of the model */
-     kvar=Tvar[TvarFind[kf]]; /* variable */
+     kvar=Tvar[TvarFind[kf]]; /* variable name */
-     k=18+Tvar[TvarFind[kf]];/*offset because there are 18 columns in the ILK_ file */
+     /* k=18+Tvar[TvarFind[kf]];/\*offset because there are 18 columns in the ILK_ file but could be placed else where *\/ */
+     /* k=18+kf;/\*offset because there are 18 columns in the ILK_ file *\/ */
+     /* k=19+kf;/\*offset because there are 19 columns in the ILK_ file *\/ */
+     k=16+nlstate+kf;/*offset because there are 19 columns in the ILK_ file, first cov Vn on col 21 with 4 living states */
      for (i=1; i<= nlstate ; i ++) {
        fprintf(ficgp,"\nset out \"%s-p%dj-%d.png\";set ylabel \"Probability for each individual/wave\";",subdirf2(optionfilefiname,"ILK_"),i,kvar);
        fprintf(ficgp,"unset log;\n# For each simple dummy covariate of the model \n plot  \"%s\"",subdirf(fileresilk));
-       fprintf(ficgp,"  u  2:($5 == %d && $6==%d ? $10 : 1/0):($%d==0 ? 7 : 9):($%d==0 ? $6 : $6+4) t \"p%d%d V%d\" with points pt variable ps 0.4 lc variable \\\n",i,1,k,k,i,1,kvar);
+       if(gnuplotversion >=5.2){ /* Former gnuplot versions do not have variable pointsize!! */
-       for (j=2; j<= nlstate+ndeath ; j ++) {
+         fprintf(ficgp,"  u  2:($5 == %d && $6==%d ? $10 : 1/0):($%d==0 ? 7 : 9):($%d==0 ? $6 : $6+4) t \"p%d%d V%d\" with points pt variable ps 0.4 lc variable \\\n",i,1,k,k,i,1,kvar);
-         fprintf(ficgp,",\\\n \"\" u  2:($5 == %d && $6==%d ? $10 : 1/0):($%d==0 ? 7 : 9):($%d==0 ? $6 : $6+4) t \"p%d%d V%d\" with points pt variable ps 0.4 lc variable ",i,j,k,k,i,j,kvar);
+         for (j=2; j<= nlstate+ndeath ; j ++) {
+           fprintf(ficgp,",\\\n \"\" u  2:($5 == %d && $6==%d ? $10 : 1/0):($%d==0 ? 7 : 9):($%d==0 ? $6 : $6+4) t \"p%d%d V%d\" with points pt variable ps 0.4 lc variable ",i,j,k,k,i,j,kvar);
+         }
+       }else{
+         fprintf(ficgp,"  u  2:($5 == %d && $6==%d ? $10 : 1/0):($%d==0 ? $6 : $6+4) t \"p%d%d V%d\" with points pt 7 ps 0.4 lc variable \\\n",i,1,k,i,1,kvar);
+         for (j=2; j<= nlstate+ndeath ; j ++) {
+           fprintf(ficgp,",\\\n \"\" u  2:($5 == %d && $6==%d ? $10 : 1/0):($%d==0 ? $6 : $6+4) t \"p%d%d V%d\" with points pt 7 ps 0.4 lc variable ",i,j,k,i,j,kvar);
+         }
        }
        fprintf(ficgp,";\nset out; unset ylabel;\n");
      }
- Line 8224  void printinggnuplot(char fileresu[], ch
+ Line 10047  void printinggnuplot(char fileresu[], ch
            fprintf(ficgp,"\nset out \"%s-p%dj-%d.png\";set ylabel \"Probability for each individual/wave\";",subdirf2(optionfilefiname,"ILK_"),i,kvar);
            fprintf(ficgp,"unset log;\n# For each simple dummy covariate of the model \n plot  \"%s\"",subdirf(fileresilk));
+             /* printf("Before DebugILK gnuplotversion=%g >=5.2\n",gnuplotversion); */
            if(gnuplotversion >=5.2){ /* Former gnuplot versions do not have variable pointsize!! */
              /* printf("DebugILK gnuplotversion=%g >=5.2\n",gnuplotversion); */
              fprintf(ficgp,"  u  2:($5 == %d && $6==%d ? $10 : 1/0):($%d==0 ? 7 : 9):($%d==0 ? $6 : $6+4) t \"p%d%d V%d\" with points pt variable ps 0.4 lc variable \\\n",i,1,k,k,i,1,kvar);
- Line 8446  void printinggnuplot(char fileresu[], ch
+ Line 10270  void printinggnuplot(char fileresu[], ch
        for(vpopbased=0; vpopbased <= popbased; vpopbased++){ /* Done for vpopbased=0 and vpopbased=1 if popbased==1*/
          fprintf(ficgp,"\nset label \"popbased %d %s\" at graph 0.98,0.5 center rotate font \"Helvetica,12\"\n",vpopbased,gplotlabel);
          if(vpopbased==0){
-           fprintf(ficgp,"set ylabel \"Years\" \nset ter svg size 640, 480\nplot [%.f:%.f] ",ageminpar,fage);
+           fprintf(ficgp,"set ylabel \"Years\" \nset ter svg size 640, 480\nunset ytics; unset y2tics; set ytics nomirror; set y2tics 0,10,100;set y2range [0:100];\nplot [%.f:%.f] ",ageminpar,fage);
          }else
            fprintf(ficgp,"\nreplot ");
-         for (i=1; i<= nlstate+1 ; i ++) {
+         for (i=1; i<= nlstate+1 ; i ++) { /* For state i-1=0 is LE, while i-1=1 to nlstate are origin state */
            k=2*i;
-           fprintf(ficgp,"\"%s\" every :::%d::%d u 1:($2==%d && $4!=0 ?$4 : 1/0) \"%%lf %%lf %%lf",subdirf2(fileresu,"T_"),nres-1,nres-1, vpopbased);
+           fprintf(ficgp,"\"%s\" every :::%d::%d u 1:($2==%d && $4!=0 ?$4 : 1/0) \"%%lf %%lf %%lf",subdirf2(fileresu,"T_"),nres-1,nres-1, vpopbased); /* for fixed variables age, popbased, mobilav */
-           for (j=1; j<= nlstate+1 ; j ++) {
+           for (j=1; j<= nlstate+1 ; j ++) { /* e.. e.1 e.2 again j-1 is the state of end, wlim_i eij*/
-             if (j==i) fprintf(ficgp," %%lf (%%lf)");
+             if (j==i) fprintf(ficgp," %%lf (%%lf)"); /* We want to read e.. i=1,j=1, e.1 i=2,j=2, e.2 i=3,j=3 */
-             else fprintf(ficgp," %%*lf (%%*lf)");
+             else fprintf(ficgp," %%*lf (%%*lf)");  /* skipping that field with a star */
            }
            if (i== 1) fprintf(ficgp,"\" t\"TLE\" w l lt %d, \\\n",i);
-           else fprintf(ficgp,"\" t\"LE in state (%d)\" w l lt %d, \\\n",i-1,i+1);
+           else fprintf(ficgp,"\" t\"LE in state (%d)\" w l lt %d, \\\n",i-1,i+1); /* state=i-1=1 to nlstate  */
            fprintf(ficgp,"\"%s\" every :::%d::%d u 1:($2==%d && $4!=0 ? $4-$5*2 : 1/0) \"%%lf %%lf %%lf",subdirf2(fileresu,"T_"),nres-1,nres-1,vpopbased);
            for (j=1; j<= nlstate+1 ; j ++) {
              if (j==i) fprintf(ficgp," %%lf (%%lf)");
- Line 8469  void printinggnuplot(char fileresu[], ch
+ Line 10293  void printinggnuplot(char fileresu[], ch
              if (j==i) fprintf(ficgp," %%lf (%%lf)");
              else fprintf(ficgp," %%*lf (%%*lf)");
            }
-           if (i== (nlstate+1)) fprintf(ficgp,"\" t\"\" w l lt 0");
+           if (i== (nlstate+1)) fprintf(ficgp,"\" t\"\" w l lt 0,\\\n"); /* ,\\\n added for th percentage graphs */
            else fprintf(ficgp,"\" t\"\" w l lt 0,\\\n");
          } /* state */
+         /* again for the percentag spent in state i-1=1 to i-1=nlstate */
+         for (i=2; i<= nlstate+1 ; i ++) { /* For state i-1=0 is LE, while i-1=1 to nlstate are origin state */
+           k=2*i;
+           fprintf(ficgp,"\"%s\" every :::%d::%d u 1:($2==%d &&  ($4)<=1 && ($4)>=0 ?($4)*100. : 1/0) \"%%lf %%lf %%lf",subdirf2(fileresu,"T_"),nres-1,nres-1, vpopbased); /* for fixed variables age, popbased, mobilav */
+           for (j=1; j<= nlstate ; j ++)
+             fprintf(ficgp," %%*lf (%%*lf)"); /* Skipping TLE and LE to read %LE only */
+           for (j=1; j<= nlstate+1 ; j ++) { /* e.. e.1 e.2 again j-1 is the state of end, wlim_i eij*/
+             if (j==i) fprintf(ficgp," %%lf (%%lf)"); /* We want to read e.. i=1,j=1, e.1 i=2,j=2, e.2 i=3,j=3 */
+             else fprintf(ficgp," %%*lf (%%*lf)");  /* skipping that field with a star */
+           }
+           if (i== 1) fprintf(ficgp,"\" t\"%%TLE\" w l lt %d axis x1y2, \\\n",i); /* Not used */
+           else fprintf(ficgp,"\" t\"%%LE in state (%d)\" w l lw 2 lt %d axis x1y2, \\\n",i-1,i+1); /* state=i-1=1 to nlstate  */
+           fprintf(ficgp,"\"%s\" every :::%d::%d u 1:($2==%d && ($4-$5*2)<=1 && ($4-$5*2)>=0? ($4-$5*2)*100. : 1/0) \"%%lf %%lf %%lf",subdirf2(fileresu,"T_"),nres-1,nres-1,vpopbased);
+           for (j=1; j<= nlstate ; j ++)
+             fprintf(ficgp," %%*lf (%%*lf)"); /* Skipping TLE and LE to read %LE only */
+           for (j=1; j<= nlstate+1 ; j ++) {
+             if (j==i) fprintf(ficgp," %%lf (%%lf)");
+             else fprintf(ficgp," %%*lf (%%*lf)");
+           }
+           fprintf(ficgp,"\" t\"\" w l lt 0 axis x1y2,");
+           fprintf(ficgp,"\"%s\" every :::%d::%d u 1:($2==%d && ($4+$5*2)<=1 && ($4+$5*2)>=0 ? ($4+$5*2)*100. : 1/0) \"%%lf %%lf %%lf",subdirf2(fileresu,"T_"),nres-1,nres-1,vpopbased);
+           for (j=1; j<= nlstate ; j ++)
+             fprintf(ficgp," %%*lf (%%*lf)"); /* Skipping TLE and LE to read %LE only */
+           for (j=1; j<= nlstate+1 ; j ++) {
+             if (j==i) fprintf(ficgp," %%lf (%%lf)");
+             else fprintf(ficgp," %%*lf (%%*lf)");
+           }
+           if (i== (nlstate+1)) fprintf(ficgp,"\" t\"\" w l lt 0 axis x1y2");
+           else fprintf(ficgp,"\" t\"\" w l lt 0 axis x1y2,\\\n");
+         } /* state for percent */
        } /* vpopbased */
        fprintf(ficgp,"\nset out;set out \"%s_%d-%d.svg\"; replot; set out; unset label;\n",subdirf2(optionfilefiname,"E_"),k1,nres); /* Buggy gnuplot */
      } /* end nres */
- Line 8866  set ter svg size 640, 480\nunset log y\n
+ Line 10720  set ter svg size 640, 480\nunset log y\n
              fprintf(ficgp," u %d:(",ioffset);
              kl=0;
              strcpy(gplotcondition,"(");
-             for (k=1; k<=cptcoveff; k++){    /* For each covariate writing the chain of conditions */
+             /* for (k=1; k<=cptcoveff; k++){    /\* For each covariate writing the chain of conditions *\/ */
                /* lv= decodtabm(k1,k,cptcoveff); /\* Should be the covariate value corresponding to combination k1 and covariate k *\/ */
-               lv=codtabm(k1,TnsdVar[Tvaraff[k]]);
+             for (k=1; k<=cptcovs; k++){    /* For each covariate k get corresponding value lv for combination k1 */
+               /* lv=codtabm(k1,TnsdVar[Tvaraff[k]]); */
+               lv=Tvresult[nres][k];
+               vlv=TinvDoQresult[nres][Tvresult[nres][k]];
                /* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 */
                /* decodtabm(1,2,4) = 1 because h=1  k=  1 (1) 1  1 */
                /* decodtabm(13,3,4)= 2 because h=13 k=  1  1 (2) 2 */
                /* vlv= nbcode[Tvaraff[k]][lv]; /\* Value of the modality of Tvaraff[k] *\/ */
-               vlv= nbcode[Tvaraff[k]][codtabm(k1,TnsdVar[Tvaraff[k]])];
+               /* vlv= nbcode[Tvaraff[k]][codtabm(k1,TnsdVar[Tvaraff[k]])]; */
                kl++;
-               sprintf(gplotcondition+strlen(gplotcondition),"$%d==%d && $%d==%d " ,kl,Tvaraff[k], kl+1, nbcode[Tvaraff[k]][lv]);
+               /* sprintf(gplotcondition+strlen(gplotcondition),"$%d==%d && $%d==%d " ,kl,Tvaraff[k], kl+1, nbcode[Tvaraff[k]][lv]); */
+               sprintf(gplotcondition+strlen(gplotcondition),"$%d==%d && $%d==%d " ,kl,lv, kl+1, vlv );
                kl++;
-               if(k <cptcoveff && cptcoveff>1)
+               if(k <cptcovs && cptcovs>1)
                  sprintf(gplotcondition+strlen(gplotcondition)," && ");
              }
              strcpy(gplotcondition+strlen(gplotcondition),")");
- Line 8961  set ter svg size 640, 480\nunset log y\n
+ Line 10819  set ter svg size 640, 480\nunset log y\n
            }else{
              fprintf(ficgp,",\\\n '' ");
            }
-           if(cptcoveff ==0){ /* No covariate */
+           /* if(cptcoveff ==0){ /\* No covariate *\/ */
+           if(cptcovs ==0){ /* No covariate */
              ioffset=2; /* Age is in 2 */
              /*# yearproj age p11 p21 p31 p.1 p12 p22 p32 p.2 p13 p23 p33 p.3 p14 p24 p34 p.4*/
              /*#   1       2   3   4   5  6    7  8   9   10  11  12  13  14  15  16  17  18 */
- Line 9073  set ter svg size 640, 480\nunset log y\n
+ Line 10932  set ter svg size 640, 480\nunset log y\n
      fprintf(ficgp,"#Number of graphics: first is logit, 2nd is probabilities, third is incidences per year\n");
      fprintf(ficgp,"#model=1+age+%s \n",model);
      fprintf(ficgp,"# Type of graphic ng=%d\n",ng);
-     fprintf(ficgp,"#   k1=1 to 2^%d=%d\n",cptcoveff,m);/* to be checked */
+     /* fprintf(ficgp,"#   k1=1 to 2^%d=%d\n",cptcoveff,m);/\* to be checked *\/ */
+     fprintf(ficgp,"#   k1=1 to 2^%d=%d\n",cptcovs,m);/* to be checked */
      /* for(k1=1; k1 <=m; k1++)  /\* For each combination of covariate *\/ */
      for(nres=1; nres <= nresult; nres++){ /* For each resultline */
       /* k1=nres; */
- Line 9198  set ter svg size 640, 480\nunset log y\n
+ Line 11058  set ter svg size 640, 480\nunset log y\n
                    } /* end Tprod */
                  }
                  break;
+               case 3:
+                 if(cptcovdageprod >0){
+                   /* if(j==Tprod[ijp]) { */ /* not necessary */
+                     /* printf("Tprod[%d]=%d, j=%d\n", ij, Tprod[ijp], j); */
+                     if(ijp <=cptcovprod) { /* Product Vn*Vm and age*VN*Vm*/
+                       if(DummyV[Tvardk[ijp][1]]==0){/* Vn is dummy */
+                         if(DummyV[Tvardk[ijp][2]]==0){/* Vn and Vm are dummy */
+                           /* fprintf(ficgp,"+p%d*%d*%d",i+j+2+nagesqr-1,nbcode[Tvard[ijp][1]][codtabm(k1,j)],nbcode[Tvard[ijp][2]][codtabm(k1,j)]); */
+                           fprintf(ficgp,"+p%d*%d*%d*x",i+j+2+nagesqr-1,Tinvresult[nres][Tvard[ijp][1]],Tinvresult[nres][Tvard[ijp][2]]);
+                         }else{ /* Vn is dummy and Vm is quanti */
+                           /* fprintf(ficgp,"+p%d*%d*%f",i+j+2+nagesqr-1,nbcode[Tvard[ijp][1]][codtabm(k1,j)],Tqinvresult[nres][Tvard[ijp][2]]); */
+                           fprintf(ficgp,"+p%d*%d*%f*x",i+j+2+nagesqr-1,Tinvresult[nres][Tvardk[ijp][1]],Tqinvresult[nres][Tvardk[ijp][2]]);
+                         }
+                       }else{ /* age* Vn*Vm Vn is quanti HERE */
+                         if(DummyV[Tvard[ijp][2]]==0){
+                           fprintf(ficgp,"+p%d*%d*%f*x",i+j+2+nagesqr-1,Tinvresult[nres][Tvardk[ijp][2]],Tqinvresult[nres][Tvardk[ijp][1]]);
+                         }else{ /* Both quanti */
+                           fprintf(ficgp,"+p%d*%f*%f*x",i+j+2+nagesqr-1,Tqinvresult[nres][Tvardk[ijp][1]],Tqinvresult[nres][Tvardk[ijp][2]]);
+                         }
+                       }
+                       ijp++;
+                     }
+                     /* } */ /* end Tprod */
+                 }
+                 break;
                case 0:
                  /* simple covariate */
                  /* fprintf(ficgp,"+p%d*%d",i+j+2+nagesqr-1,nbcode[Tvar[j]][codtabm(k1,j)]); /\* Valgrind bug nbcode *\/ */
- Line 9284  set ter svg size 640, 480\nunset log y\n
+ Line 11169  set ter svg size 640, 480\nunset log y\n
                      } /* end Tprod */
                    } /* end if */
                    break;
+                 case 3:
+                   if(cptcovdageprod >0){
+                     /* if(j==Tprod[ijp]) { /\* *\/  */
+                       /* printf("Tprod[%d]=%d, j=%d\n", ij, Tprod[ijp], j); */
+                       if(ijp <=cptcovprod) { /* Product */
+                         if(DummyV[Tvardk[ijp][1]]==0){/* Vn is dummy */
+                           if(DummyV[Tvardk[ijp][2]]==0){/* Vn and Vm are dummy */
+                             /* fprintf(ficgp,"+p%d*%d*%d",i+j+2+nagesqr-1,nbcode[Tvard[ijp][1]][codtabm(k1,j)],nbcode[Tvard[ijp][2]][codtabm(k1,j)]); */
+                             fprintf(ficgp,"+p%d*%d*%d*x",k3+(cpt-1)*ncovmodel+1+j+nagesqr,Tinvresult[nres][Tvardk[ijp][1]],Tinvresult[nres][Tvardk[ijp][2]]);
+                             /* fprintf(ficgp,"+p%d*%d*%d",i+j+2+nagesqr-1,Tinvresult[nres][Tvard[ijp][1]],Tinvresult[nres][Tvard[ijp][2]]); */
+                           }else{ /* Vn is dummy and Vm is quanti */
+                             /* fprintf(ficgp,"+p%d*%d*%f",i+j+2+nagesqr-1,nbcode[Tvard[ijp][1]][codtabm(k1,j)],Tqinvresult[nres][Tvard[ijp][2]]); */
+                             fprintf(ficgp,"+p%d*%d*%f*x",k3+(cpt-1)*ncovmodel+1+j+nagesqr,Tinvresult[nres][Tvardk[ijp][1]],Tqinvresult[nres][Tvardk[ijp][2]]);
+                             /* fprintf(ficgp,"+p%d*%d*%f*x",i+j+2+nagesqr-1,Tinvresult[nres][Tvard[ijp][1]],Tqinvresult[nres][Tvard[ijp][2]]); */
+                           }
+                         }else{ /* Vn*Vm Vn is quanti */
+                           if(DummyV[Tvardk[ijp][2]]==0){
+                             fprintf(ficgp,"+p%d*%d*%f",k3+(cpt-1)*ncovmodel+1+j+nagesqr,Tinvresult[nres][Tvardk[ijp][2]],Tqinvresult[nres][Tvardk[ijp][1]]);
+                             /* fprintf(ficgp,"+p%d*%d*%f*x",i+j+2+nagesqr-1,Tinvresult[nres][Tvard[ijp][2]],Tqinvresult[nres][Tvard[ijp][1]]); */
+                           }else{ /* Both quanti */
+                             fprintf(ficgp,"+p%d*%f*%f",k3+(cpt-1)*ncovmodel+1+j+nagesqr,Tqinvresult[nres][Tvardk[ijp][1]],Tqinvresult[nres][Tvardk[ijp][2]]);
+                             /* fprintf(ficgp,"+p%d*%f*%f*x",i+j+2+nagesqr-1,Tqinvresult[nres][Tvard[ijp][1]],Tqinvresult[nres][Tvard[ijp][2]]); */
+                           }
+                         }
+                         ijp++;
+                       }
+                     /* } /\* end Tprod *\/ */
+                   } /* end if */
+                   break;
                  case 0:
                    /* simple covariate */
                    /* fprintf(ficgp,"+p%d*%d",i+j+2+nagesqr-1,nbcode[Tvar[j]][codtabm(k1,j)]); /\* Valgrind bug nbcode *\/ */
- Line 9581  void prevforecast(char fileres[], double
+ Line 11495  void prevforecast(char fileres[], double
    */
    /* double anprojd, mprojd, jprojd; */
    /* double anprojf, mprojf, jprojf; */
-   int yearp, stepsize, hstepm, nhstepm, j, k, cptcod, i, h, i1, k4, nres=0;
+   int yearp, stepsize, hstepm, nhstepm, j, k, i, h,  nres=0;
    double agec; /* generic age */
-   double agelim, ppij, yp,yp1,yp2;
+   double agelim, ppij;
-   double *popeffectif,*popcount;
+   /*double *popcount;*/
    double ***p3mat;
    /* double ***mobaverage; */
    char fileresf[FILENAMELENGTH];
- Line 9637  void prevforecast(char fileres[], double
+ Line 11551  void prevforecast(char fileres[], double
    /* date2dmy(dateintmean,&jintmean,&mintmean,&aintmean); */
    /* date2dmy(dateprojd,&jprojd, &mprojd, &anprojd); */
    /* date2dmy(dateprojf,&jprojf, &mprojf, &anprojf); */
-   i1=pow(2,cptcoveff);
+   /* i1=pow(2,cptcoveff); */
-   if (cptcovn < 1){i1=1;}
+   /* if (cptcovn < 1){i1=1;} */
    fprintf(ficresf,"# Mean day of interviews %.lf/%.lf/%.lf (%.2f) between %.2f and %.2f \n",jintmean,mintmean,aintmean,dateintmean,dateprev1,dateprev2);
    fprintf(ficresf,"#****** Routine prevforecast **\n");
  /*            if (h==(int)(YEARM*yearp)){ */
-   for(nres=1; nres <= nresult; nres++) /* For each resultline */
+   for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-     for(k=1; k<=i1;k++){ /* We want to find the combination k corresponding to the values of the dummies given in this resut line (to be cleaned one day) */
+     k=TKresult[nres];
-     if(i1 != 1 && TKresult[nres]!= k)
+     if(TKresult[nres]==0) k=1; /* To be checked for noresult */
-       continue;
+     /*  for(k=1; k<=i1;k++){ /\* We want to find the combination k corresponding to the values of the dummies given in this resut line (to be cleaned one day) *\/ */
-     if(invalidvarcomb[k]){
+     /* if(i1 != 1 && TKresult[nres]!= k) */
-       printf("\nCombination (%d) projection ignored because no cases \n",k);
+     /*   continue; */
-       continue;
+     /* if(invalidvarcomb[k]){ */
-     }
+     /*   printf("\nCombination (%d) projection ignored because no cases \n",k);  */
+     /*   continue; */
+     /* } */
      fprintf(ficresf,"\n#****** hpijx=probability over h years, hp.jx is weighted by observed prev \n#");
-     for(j=1;j<=cptcoveff;j++) {
+     for(j=1;j<=cptcovs;j++){
-       /* fprintf(ficresf," V%d (=) %d",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,Tvaraff[j])]); */
+       /* for(j=1;j<=cptcoveff;j++) { */
-       fprintf(ficresf," V%d (=) %d",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]);
+     /*   /\* fprintf(ficresf," V%d (=) %d",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,Tvaraff[j])]); *\/ */
-     }
+     /*   fprintf(ficresf," V%d (=) %d",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
-     for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
+     /* } */
-       fprintf(ficresf," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+     /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
+     /*   fprintf(ficresf," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]); */
+     /* } */
+       fprintf(ficresf," V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
      }
      fprintf(ficresf," yearproj age");
      for(j=1; j<=nlstate+ndeath;j++){
        for(i=1; i<=nlstate;i++)
- Line 9685  void prevforecast(char fileres[], double
+ Line 11605  void prevforecast(char fileres[], double
            }
          }
          fprintf(ficresf,"\n");
-         for(j=1;j<=cptcoveff;j++)
+         /* for(j=1;j<=cptcoveff;j++)  */
+         for(j=1;j<=cptcovs;j++)
+           fprintf(ficresf,"%d %lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
            /* fprintf(ficresf,"%d %d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,Tvaraff[j])]); /\* Tvaraff not correct *\/ */
-           fprintf(ficresf,"%d %d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); /* TnsdVar[Tvaraff]  correct */
+           /* fprintf(ficresf,"%d %d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); /\* TnsdVar[Tvaraff]  correct *\/ */
          fprintf(ficresf,"%.f %.f ",anprojd+yearp,agec+h*hstepm/YEARM*stepm);
          for(j=1; j<=nlstate+ndeath;j++) {
- Line 9724  void prevforecast(char fileres[], double
+ Line 11646  void prevforecast(char fileres[], double
       anback2 year of end of backprojection (same day and month as back1).
       prevacurrent and prev are prevalences.
    */
-   int yearp, stepsize, hstepm, nhstepm, j, k, cptcod, i, h, i1, k4, nres=0;
+   int yearp, stepsize, hstepm, nhstepm, j, k,  i, h, nres=0;
    double agec; /* generic age */
-   double agelim, ppij, ppi, yp,yp1,yp2; /* ,jintmean,mintmean,aintmean;*/
+   double agelim, ppij, ppi; /* ,jintmean,mintmean,aintmean;*/
-   double *popeffectif,*popcount;
+   /*double *popcount;*/
    double ***p3mat;
    /* double ***mobaverage; */
    char fileresfb[FILENAMELENGTH];
- Line 9779  void prevforecast(char fileres[], double
+ Line 11701  void prevforecast(char fileres[], double
    /* if(jintmean==0) jintmean=1; */
    /* if(mintmean==0) jintmean=1; */
-   i1=pow(2,cptcoveff);
+   /* i1=pow(2,cptcoveff); */
-   if (cptcovn < 1){i1=1;}
+   /* if (cptcovn < 1){i1=1;} */
    fprintf(ficresfb,"# Mean day of interviews %.lf/%.lf/%.lf (%.2f) between %.2f and %.2f \n",jintmean,mintmean,aintmean,dateintmean,dateprev1,dateprev2);
    printf("# Mean day of interviews %.lf/%.lf/%.lf (%.2f) between %.2f and %.2f \n",jintmean,mintmean,aintmean,dateintmean,dateprev1,dateprev2);
    fprintf(ficresfb,"#****** Routine prevbackforecast **\n");
-   for(nres=1; nres <= nresult; nres++) /* For each resultline */
+   for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-   for(k=1; k<=i1;k++){
+     k=TKresult[nres];
-     if(i1 != 1 && TKresult[nres]!= k)
+     if(TKresult[nres]==0) k=1; /* To be checked for noresult */
-       continue;
+   /* for(k=1; k<=i1;k++){ */
-     if(invalidvarcomb[k]){
+   /*   if(i1 != 1 && TKresult[nres]!= k) */
-       printf("\nCombination (%d) projection ignored because no cases \n",k);
+   /*     continue; */
-       continue;
+   /*   if(invalidvarcomb[k]){ */
-     }
+   /*     printf("\nCombination (%d) projection ignored because no cases \n",k);  */
+   /*     continue; */
+   /*   } */
      fprintf(ficresfb,"\n#****** hbijx=probability over h years, hb.jx is weighted by observed prev \n#");
-     for(j=1;j<=cptcoveff;j++) {
+     for(j=1;j<=cptcovs;j++){
-       fprintf(ficresfb," V%d (=) %d",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]);
+     /* for(j=1;j<=cptcoveff;j++) { */
-     }
+     /*   fprintf(ficresfb," V%d (=) %d",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
-     for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
+     /* } */
-       fprintf(ficresf," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+       fprintf(ficresfb," V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
      }
+    /*  fprintf(ficrespij,"******\n"); */
+    /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
+    /*    fprintf(ficresfb," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]); */
+    /*  } */
      fprintf(ficresfb," yearbproj age");
      for(j=1; j<=nlstate+ndeath;j++){
        for(i=1; i<=nlstate;i++)
- Line 9832  void prevforecast(char fileres[], double
+ Line 11760  void prevforecast(char fileres[], double
            }
          }
          fprintf(ficresfb,"\n");
-         for(j=1;j<=cptcoveff;j++)
+         /* for(j=1;j<=cptcoveff;j++) */
-           fprintf(ficresfb,"%d %d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]);
+         for(j=1;j<=cptcovs;j++)
+           fprintf(ficresfb,"%d %lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
+           /* fprintf(ficresfb,"%d %d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
          fprintf(ficresfb,"%.f %.f ",anbackd+yearp,agec-h*hstepm/YEARM*stepm);
          for(i=1; i<=nlstate+ndeath;i++) {
            ppij=0.;ppi=0.;
- Line 10402  void printinggnuplotmort(char fileresu[]
+ Line 12332  void printinggnuplotmort(char fileresu[]
    char dirfileres[132],optfileres[132];
-   int ng;
+   /*int ng;*/
    /*#ifdef windows */
- Line 10426  int readdata(char datafile[], int firsto
+ Line 12356  int readdata(char datafile[], int firsto
    /*-------- data file ----------*/
    FILE *fic;
    char dummy[]="                         ";
-   int i=0, j=0, n=0, iv=0, v;
+   int i = 0, j = 0, n = 0, iv = 0;/* , v;*/
    int lstra;
    int linei, month, year,iout;
    int noffset=0; /* This is the offset if BOM data file */
- Line 10434  int readdata(char datafile[], int firsto
+ Line 12364  int readdata(char datafile[], int firsto
    char stra[MAXLINE], strb[MAXLINE];
    char *stratrunc;
-   DummyV=ivector(1,NCOVMAX); /* 1 to 3 */
+   /* DummyV=ivector(-1,NCOVMAX); /\* 1 to 3 *\/ */
-   FixedV=ivector(1,NCOVMAX); /* 1 to 3 */
+   /* FixedV=ivector(-1,NCOVMAX); /\* 1 to 3 *\/ */
-   for(v=1;v<NCOVMAX;v++){
-     DummyV[v]=0;
-     FixedV[v]=0;
-   }
-   for(v=1; v <=ncovcol;v++){
-     DummyV[v]=0;
-     FixedV[v]=0;
-   }
-   for(v=ncovcol+1; v <=ncovcol+nqv;v++){
-     DummyV[v]=1;
-     FixedV[v]=0;
-   }
-   for(v=ncovcol+nqv+1; v <=ncovcol+nqv+ntv;v++){
-     DummyV[v]=0;
-     FixedV[v]=1;
-   }
-   for(v=ncovcol+nqv+ntv+1; v <=ncovcol+nqv+ntv+nqtv;v++){
-     DummyV[v]=1;
-     FixedV[v]=1;
-   }
-   for(v=1; v <=ncovcol+nqv+ntv+nqtv;v++){
-     printf("Covariate type in the data: V%d, DummyV(V%d)=%d, FixedV(V%d)=%d\n",v,v,DummyV[v],v,FixedV[v]);
-     fprintf(ficlog,"Covariate type in the data: V%d, DummyV(V%d)=%d, FixedV(V%d)=%d\n",v,v,DummyV[v],v,FixedV[v]);
-   }
    ncovcolt=ncovcol+nqv+ntv+nqtv; /* total of covariates in the data, not in the model equation */
- Line 10613  int readdata(char datafile[], int firsto
+ Line 12518  int readdata(char datafile[], int firsto
          errno=0;
          lval=strtol(strb,&endptr,10);
          /*      if (errno == ERANGE && (lval == LONG_MAX || lval == LONG_MIN))*/
-         if( strb[0]=='\0' || (*endptr != '\0')){
+         if( strb[0]=='\0' || (*endptr != '\0' )){
-           printf("Error reading data around '%s' at line number %d for individual %d, '%s'\nShould be a status of wave %d. Setting maxwav=%d might be wrong.  Exiting.\n", strb, linei,i,line,j,maxwav);
+           printf("Error reading data around '%s' at line number %d for individual %d, '%s'\nShould be a status of wave %d. Setting maxwav=%d might be wrong. Exiting.\n", strb, linei,i,line,j,maxwav);
-           fprintf(ficlog,"Error reading data around '%s' at line number %d for individual %d, '%s'\nShould be a status of wave %d. Setting maxwav=%d might be wrong.  Exiting.\n", strb, linei,i,line,j,maxwav);fflush(ficlog);
+           fprintf(ficlog,"Error reading data around '%s' at line number %d for individual %d, '%s'\nShould be a status of wave %d. Setting maxwav=%d might be wrong. Exiting.\n", strb, linei,i,line,j,maxwav);fflush(ficlog);
+           return 1;
+         }else if( lval==0 || lval > nlstate+ndeath){
+           printf("Error in data around '%s' at line number %d for individual %d, '%s'\n Should be a state at wave %d. A state should be 1 to %d and not %ld.\n Fix your data file '%s'!  Exiting.\n", strb, linei,i,line,j,nlstate+ndeath, lval, datafile);fflush(stdout);
+           fprintf(ficlog,"Error in data around '%s' at line number %d for individual %d, '%s'\n Should be a state at wave %d. A state should be 1 to %d and not %ld.\n Fix your data file '%s'!  Exiting.\n", strb, linei,i,line,j,nlstate+ndeath, lval, datafile); fflush(ficlog);
            return 1;
          }
        }
- Line 10818  int decoderesult( char resultline[], int
+ Line 12727  int decoderesult( char resultline[], int
    if (strlen(resultsav) >1){
      j=nbocc(resultsav,'='); /**< j=Number of covariate values'=' in this resultline */
    }
-   if(j == 0){ /* Resultline but no = */
+   if(j == 0 && cptcovs== 0){ /* Resultline but no =  and no covariate in the model */
      TKresult[nres]=0; /* Combination for the nresult and the model */
      return (0);
    }
    if( j != cptcovs ){ /* Be careful if a variable is in a product but not single */
-     printf("ERROR: the number of variables in the resultline which is %d, differs from the number %d of single variables used in the model line, %s.\n",j, cptcovs, model);
+     fprintf(ficlog,"ERROR: the number of variables in the resultline which is %d, differs from the number %d of single variables used in the model line, 1+age+%s.\n",j, cptcovs, model);fflush(ficlog);
-     fprintf(ficlog,"ERROR: the number of variables in the resultline which is %d, differs from the number %d of single variables used in the model line, %s.\n",j, cptcovs, model);
+     printf("ERROR: the number of variables in the resultline which is %d, differs from the number %d of single variables used in the model line, 1+age+%s.\n",j, cptcovs, model);fflush(stdout);
-     /* return 1;*/
+     if(j==0)
+       return 1;
    }
    for(k=1; k<=j;k++){ /* Loop on any covariate of the RESULT LINE */
      if(nbocc(resultsav,'=') >1){
- Line 10884  int decoderesult( char resultline[], int
+ Line 12794  int decoderesult( char resultline[], int
          fprintf(ficlog,"Error in result line (Product with age): V%d is missing in result: %s according to model=1+age+%s (Tvarsel[k2=%d]=%d)\n",Tvar[k1], resultline, model, k2, Tvarsel[k2]);
        return 1;
        }
-     }else if(Typevar[k1]==2){ /* Product No age We want to get the position in the resultline of the product in the model line*/
+     }else if(Typevar[k1]==2 || Typevar[k1]==3){ /* Product with or without age. We want to get the position in the resultline of the product in the model line*/
        /* resultmodel[nres][of such a Vn * Vm product k1] is not unique, so can't exist, we feed Tvard[k1][1] and [2] */
        match=0;
        /* printf("Decoderesult very first Product Tvardk[k1=%d][1]=%d Tvardk[k1=%d][2]=%d V%d * V%d\n",k1,Tvardk[k1][1],k1,Tvardk[k1][2],Tvardk[k1][1],Tvardk[k1][2]); */
- Line 10896  int decoderesult( char resultline[], int
+ Line 12806  int decoderesult( char resultline[], int
          }
        }
        if(match == 0){
-         printf("Error in result line (Product without age first variable): V%d is missing in result: %s according to model=1+age+%s\n",Tvardk[k1][1], resultline, model);
+         printf("Error in result line (Product without age first variable or double product with age): V%d is missing in result: %s according to model=1+age+%s\n",Tvardk[k1][1], resultline, model);
-         fprintf(ficlog,"Error in result line (Product without age first variable): V%d is missing in result: %s according to model=1+age+%s\n",Tvardk[k1][1], resultline, model);
+         fprintf(ficlog,"Error in result line (Product without age first variable or double product with age): V%d is missing in result: %s according to model=1+age+%s\n",Tvardk[k1][1], resultline, model);
          return 1;
        }
        match=0;
- Line 10910  int decoderesult( char resultline[], int
+ Line 12820  int decoderesult( char resultline[], int
          }
        }
        if(match == 0){
-         printf("Error in result line (Product without age second variable): V%d is missing in result: %s according to model=1+age+%s\n",Tvardk[k1][2], resultline, model);
+         printf("Error in result line (Product without age second variable or double product with age): V%d is missing in result: %s according to model=1+age+%s\n",Tvardk[k1][2], resultline, model);
-         fprintf(ficlog,"Error in result line (Product without age second variable): V%d is missing in result : %s according to model=1+age+%s\n",Tvardk[k1][2], resultline, model);
+         fprintf(ficlog,"Error in result line (Product without age second variable or double product with age): V%d is missing in result : %s according to model=1+age+%s\n",Tvardk[k1][2], resultline, model);
          return 1;
        }
      }/* End of testing */
- Line 10923  int decoderesult( char resultline[], int
+ Line 12833  int decoderesult( char resultline[], int
      match=0;
      for(k1=1; k1<= cptcovt ;k1++){ /* loop on model: model line V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */
        if(Typevar[k1]==0){ /* Single only */
-         if(Tvar[k1]==Tvarsel[k2]) { /* Tvar[2]=4 == Tvarsel[1]=4   */
+         if(Tvar[k1]==Tvarsel[k2]) { /* Tvar[2]=4 == Tvarsel[1]=4  What if a product?  */
            resultmodel[nres][k1]=k2;  /* k1th position in the model equation corresponds to k2th position in the result line. resultmodel[2]=1 resultmodel[1]=2  resultmodel[3]=3  resultmodel[6]=4 resultmodel[9]=5 */
            modelresult[nres][k2]=k1; /* k1th position in the model equation corresponds to k2th position in the result line. modelresult[1]=2 modelresult[2]=1  modelresult[3]=3  remodelresult[4]=6 modelresult[5]=9 */
            ++match;
- Line 10964  int decoderesult( char resultline[], int
+ Line 12874  int decoderesult( char resultline[], int
      /* k counting number of combination of single dummies in the equation model */
      /* k4 counting single dummies in the equation model */
      /* k4q counting single quantitatives in the equation model */
-     if( Dummy[k1]==0 && Typevar[k1]==0 ){ /* Dummy and Single, k1 is sorting according to MODEL, but k3 to resultline */
+     if( Dummy[k1]==0 && Typevar[k1]==0 ){ /* Dummy and Single, fixed or timevarying, k1 is sorting according to MODEL, but k3 to resultline */
         /* k4+1= (not always if quant in model) position in the resultline V(Tvarsel)=Tvalsel=Tresult[nres][pos](value); V(Tvresult[nres][pos] (variable): V(variable)=value) */
        /* modelresult[k3]=k1: k3th position in the result line corresponds to the k1 position in the model line (doesn't work with products)*/
        /* Value in the (current nres) resultline of the variable at the k1th position in the model equation resultmodel[nres][k1]= k3 */
- Line 11008  int decoderesult( char resultline[], int
+ Line 12918  int decoderesult( char resultline[], int
        precov[nres][k1]=Tvalsel[k3q];
        /* printf("Decoderesult Quantitative nres=%d,precov[nres=%d][k1=%d]=%.f V(k2q=V%d)= Tvalsel[%d]=%d, Tvarsel[%d]=%f\n",nres, nres, k1,precov[nres][k1], k2q, k3q, Tvarsel[k3q], k3q, Tvalsel[k3q]); */
        k4q++;;
-     }else if( Dummy[k1]==2 ){ /* For dummy with age product */
+     }else if( Dummy[k1]==2 ){ /* For dummy with age product "V2+V3+V4+V6+V7+V6*V2+V7*V2+V6*V3+V7*V3+V6*V4+V7*V4+age*V2+age*V3+age*V4+age*V6+age*V7+age*V6*V2+age*V6*V3+age*V7*V3+age*V6*V4+age*V7*V4\r"*/
-       /* Tvar[k1]; */ /* Age variable */
+       /* Tvar[k1]; */ /* Age variable */ /* 17 age*V6*V2 ?*/
        /* Wrong we want the value of variable name Tvar[k1] */
+       if(Typevar[k1]==2 || Typevar[k1]==3 ){ /* For product quant or dummy (with or without age) */
-       k3= resultmodel[nres][k1]; /* nres=1 k1=2 resultmodel[2(V4)] = 1=k3 ; k1=3 resultmodel[3(V3)] = 2=k3*/
+         precov[nres][k1]=TinvDoQresult[nres][Tvardk[k1][1]] * TinvDoQresult[nres][Tvardk[k1][2]];
-       k2=(int)Tvarsel[k3]; /* nres=1 k1=2=>k3=1 Tvarsel[resultmodel[2]]= Tvarsel[1] = 4=k2 (V4); k1=3=>k3=2 Tvarsel[2]=3 (V3)*/
+       /* printf("Decoderesult Quantitative or Dummy (not with age) nres=%d k1=%d precov[nres=%d][k1=%d]=%.f V%d(=%.f) * V%d(=%.f) \n",nres, k1, nres, k1,precov[nres][k1], Tvardk[k1][1], TinvDoQresult[nres][Tvardk[k1][1]], Tvardk[k1][2], TinvDoQresult[nres][Tvardk[k1][2]]); */
-       TinvDoQresult[nres][(int)Tvarsel[k3]]=Tvalsel[k3]; /* TinvDoQresult[nres][4]=1 */
+       }else{
-       precov[nres][k1]=Tvalsel[k3];
+         k3= resultmodel[nres][k1]; /* nres=1 k1=2 resultmodel[2(V4)] = 1=k3 ; k1=3 resultmodel[3(V3)] = 2=k3*/
+         k2=(int)Tvarsel[k3]; /* nres=1 k1=2=>k3=1 Tvarsel[resultmodel[2]]= Tvarsel[1] = 4=k2 (V4); k1=3=>k3=2 Tvarsel[2]=3 (V3)*/
+         TinvDoQresult[nres][(int)Tvarsel[k3]]=Tvalsel[k3]; /* TinvDoQresult[nres][4]=1 */
+         precov[nres][k1]=Tvalsel[k3];
+       }
        /* printf("Decoderesult Dummy with age k=%d, k1=%d precov[nres=%d][k1=%d]=%.f Tvar[%d]=V%d k2=Tvarsel[%d]=%d Tvalsel[%d]=%d\n",k, k1, nres, k1,precov[nres][k1], k1, Tvar[k1], k3,(int)Tvarsel[k3], k3, (int)Tvalsel[k3]); */
      }else if( Dummy[k1]==3 ){ /* For quant with age product */
-       k3q= resultmodel[nres][k1]; /* resultmodel[1(V5)] = 25.1=k3q */
+       if(Typevar[k1]==2 || Typevar[k1]==3 ){ /* For product quant or dummy (with or without age) */
-       k2q=(int)Tvarsel[k3q]; /*  Tvarsel[resultmodel[1]]= Tvarsel[1] = 4=k2 */
+         precov[nres][k1]=TinvDoQresult[nres][Tvardk[k1][1]] * TinvDoQresult[nres][Tvardk[k1][2]];
-       TinvDoQresult[nres][(int)Tvarsel[k3q]]=Tvalsel[k3q]; /* TinvDoQresult[nres][5]=25.1 */
+       /* printf("Decoderesult Quantitative or Dummy (not with age) nres=%d k1=%d precov[nres=%d][k1=%d]=%.f V%d(=%.f) * V%d(=%.f) \n",nres, k1, nres, k1,precov[nres][k1], Tvardk[k1][1], TinvDoQresult[nres][Tvardk[k1][1]], Tvardk[k1][2], TinvDoQresult[nres][Tvardk[k1][2]]); */
-       precov[nres][k1]=Tvalsel[k3q];
+       }else{
+         k3q= resultmodel[nres][k1]; /* resultmodel[1(V5)] = 25.1=k3q */
+         k2q=(int)Tvarsel[k3q]; /*  Tvarsel[resultmodel[1]]= Tvarsel[1] = 4=k2 */
+         TinvDoQresult[nres][(int)Tvarsel[k3q]]=Tvalsel[k3q]; /* TinvDoQresult[nres][5]=25.1 */
+         precov[nres][k1]=Tvalsel[k3q];
+       }
        /* printf("Decoderesult Quantitative with age nres=%d, k1=%d, precov[nres=%d][k1=%d]=%f Tvar[%d]=V%d V(k2q=%d)= Tvarsel[%d]=%d, Tvalsel[%d]=%f\n",nres, k1, nres, k1,precov[nres][k1], k1,  Tvar[k1], k2q, k3q, Tvarsel[k3q], k3q, Tvalsel[k3q]); */
-     }else if(Typevar[k1]==2 ){ /* For product quant or dummy (not with age) */
+     }else if(Typevar[k1]==2 || Typevar[k1]==3 ){ /* For product quant or dummy (with or without age) */
        precov[nres][k1]=TinvDoQresult[nres][Tvardk[k1][1]] * TinvDoQresult[nres][Tvardk[k1][2]];
        /* printf("Decoderesult Quantitative or Dummy (not with age) nres=%d k1=%d precov[nres=%d][k1=%d]=%.f V%d(=%.f) * V%d(=%.f) \n",nres, k1, nres, k1,precov[nres][k1], Tvardk[k1][1], TinvDoQresult[nres][Tvardk[k1][1]], Tvardk[k1][2], TinvDoQresult[nres][Tvardk[k1][2]]); */
      }else{
- Line 11054  int decodemodel( char model[], int lasto
+ Line 12973  int decodemodel( char model[], int lasto
          */
  /* V2+V1+V4+V3*age Tvar[4]=3 ; V1+V2*age Tvar[2]=2; V1+V1*age Tvar[2]=1, Tage[1]=2 */
  {
-   int i, j, k, ks, v;
+   int i, j, k, ks;/* , v;*/
-   int  j1, k1, k2, k3, k4;
+   int n,m;
-   char modelsav[80];
+   int  j1, k1, k11, k12, k2, k3, k4;
-   char stra[80], strb[80], strc[80], strd[80],stre[80];
+   char modelsav[300];
+   char stra[300], strb[300], strc[300], strd[300],stre[300],strf[300];
    char *strpt;
+   int  **existcomb;
+   existcomb=imatrix(1,NCOVMAX,1,NCOVMAX);
+   for(i=1;i<=NCOVMAX;i++)
+     for(j=1;j<=NCOVMAX;j++)
+       existcomb[i][j]=0;
    /*removespace(model);*/
    if (strlen(model) >1){ /* If there is at least 1 covariate */
-     j=0, j1=0, k1=0, k2=-1, ks=0, cptcovn=0;
+     j=0, j1=0, k1=0, k12=0, k2=-1, ks=0, cptcovn=0;
      if (strstr(model,"AGE") !=0){
        printf("Error. AGE must be in lower case 'age' model=1+age+%s. ",model);
        fprintf(ficlog,"Error. AGE must be in lower case model=1+age+%s. ",model);fflush(ficlog);
- Line 11094  int decodemodel( char model[], int lasto
+ Line 13020  int decodemodel( char model[], int lasto
          substrchaine(modelsav, model, "age*age");
      }else
        nagesqr=0;
-     if (strlen(modelsav) >1){
+     if (strlen(modelsav) >1){ /* V2 +V3 +V4 +V6 +V7 +V6*V2 +V7*V2 +V6*V3 +V7*V3 +V6*V4 +V7*V4 +age*V2 +age*V3 +age*V4 +age*V6 +age*V7 +age*V6*V2 +V7*V2 +age*V6*V3 +age*V7*V3 +age*V6*V4 +age*V7*V4 */
        j=nbocc(modelsav,'+'); /**< j=Number of '+' */
        j1=nbocc(modelsav,'*'); /**< j1=Number of '*' */
-       cptcovs=j+1-j1; /**<  Number of simple covariates V1+V1*age+V3 +V3*V4+age*age=> V1 + V3 =5-3=2  */
+       cptcovs=0; /**<  Number of simple covariates V1 +V1*age +V3 +V3*V4 +age*age => V1 + V3 =4+1-3=2  Wrong */
        cptcovt= j+1; /* Number of total covariates in the model, not including
                       * cst, age and age*age
                       * V1+V1*age+ V3 + V3*V4+age*age=> 3+1=4*/
        /* including age products which are counted in cptcovage.
         * but the covariates which are products must be treated
         * separately: ncovn=4- 2=2 (V1+V3). */
-       cptcovprod=j1; /**< Number of products  V1*V2 +v3*age = 2 */
+       cptcovprod=0; /**< Number of products  V1*V2 +v3*age = 2 */
+       cptcovdageprod=0; /* Number of doouble products with age age*Vn*VM or Vn*age*Vm or Vn*Vm*age */
        cptcovprodnoage=0; /**< Number of covariate products without age: V3*V4 =1  */
+       cptcovprodage=0;
+       /* cptcovprodage=nboccstr(modelsav,"age");*/
        /*   Design
         *  V1   V2   V3   V4  V5  V6  V7  V8  V9 Weight
- Line 11114  int decodemodel( char model[], int lasto
+ Line 13042  int decodemodel( char model[], int lasto
         * Model V2 + V1 + V3*age + V3 + V5*V6 + V7*V8 + V8*age + V8
         *   k=  1    2      3       4     5       6      7        8
         *  cptcovn number of covariates (not including constant and age ) = # of + plus 1 = 7+1=8
-        *  covar[k,i], value of kth covariate if not including age for individual i:
+        *  covar[k,i], are for fixed covariates, value of kth covariate if not including age for individual i:
         *       covar[1][i]= (V1), covar[4][i]=(V4), covar[8][i]=(V8)
         *  Tvar[k] # of the kth covariate:  Tvar[1]=2  Tvar[2]=1 Tvar[4]=3 Tvar[8]=8
         *       if multiplied by age: V3*age Tvar[3=V3*age]=3 (V3) Tvar[7]=8 and
         *  Tage[++cptcovage]=k
-        *       if products, new covar are created after ncovcol with k1
+        *       if products, new covar are created after ncovcol + nqv (quanti fixed) with k1
         *  Tvar[k]=ncovcol+k1; # of the kth covariate product:  Tvar[5]=ncovcol+1=10  Tvar[6]=ncovcol+1=11
         *  Tprod[k1]=k; Tprod[1]=5 Tprod[2]= 6; gives the position of the k1th product
         *  Tvard[k1][1]=m Tvard[k1][2]=m; Tvard[1][1]=5 (V5) Tvard[1][2]=6 Tvard[2][1]=7 (V7) Tvard[2][2]=8
         *  Tvar[cptcovn+k2]=Tvard[k1][1];Tvar[cptcovn+k2+1]=Tvard[k1][2];
         *  Tvar[8+1]=5;Tvar[8+2]=6;Tvar[8+3]=7;Tvar[8+4]=8 inverted
         *  V1   V2   V3   V4  V5  V6  V7  V8  V9  V10  V11
-        *  <          ncovcol=8                >
+        *  <          ncovcol=8  8 fixed covariate. Additional starts at 9 (V5*V6) and 10(V7*V8)              >
         *       Model V2 + V1 + V3*age + V3 + V5*V6 + V7*V8 + V8*age + V8    d1   d1   d2  d2
         *          k=  1    2      3       4     5       6      7        8    9   10   11  12
-        *     Tvar[k]= 2    1      3       3    10      11      8        8    5    6    7   8
+        *     Tvard[k]= 2    1      3       3    10      11      8        8    5    6    7   8
-        * p Tvar[1]@12={2,   1,     3,      3,  11,     10,     8,       8,   7,   8,   5,  6}
+        * p Tvar[1]@12={2,   1,     3,      3,   9,     10,     8,       8}
         * p Tprod[1]@2={                         6, 5}
         *p Tvard[1][1]@4= {7, 8, 5, 6}
         * covar[k][i]= V2   V1      ?      V3    V5*V6?   V7*V8?  ?       V8
- Line 11160  int decodemodel( char model[], int lasto
+ Line 13088  int decodemodel( char model[], int lasto
          Tvar[k]=0; Tprod[k]=0; Tposprod[k]=0;
        }
        cptcovage=0;
+       /* First loop in order to calculate */
+       /* for age*VN*Vm
+        * Provides, Typevar[k], Tage[cptcovage], existcomb[n][m], FixedV[ncovcolt+k12]
+        * Tprod[k1]=k  Tposprod[k]=k1;    Tvard[k1][1] =m;
+       */
+       /* Needs  FixedV[Tvardk[k][1]] */
+       /* For others:
+        * Sets   Typevar[k];
+        * Tvar[k]=ncovcol+nqv+ntv+nqtv+k11;
+        *        Tposprod[k]=k11;
+        *        Tprod[k11]=k;
+        *        Tvardk[k][1] =m;
+        * Needs FixedV[Tvardk[k][1]] == 0
+       */
        for(k=1; k<=cptcovt;k++){ /* Loop on total covariates of the model line */
          cutl(stra,strb,modelsav,'+'); /* keeps in strb after the first '+' cutl from left to right
                                           modelsav==V2+V1+V5*age+V4+V3*age strb=V3*age stra=V2+V1V5*age+V4 */    /* <model> "V5+V4+V3+V4*V3+V5*age+V1*age+V1" strb="V5" stra="V4+V3+V4*V3+V5*age+V1*age+V1" */
- Line 11167  int decodemodel( char model[], int lasto
+ Line 13111  int decodemodel( char model[], int lasto
            strcpy(strb,modelsav); /* and analyzes it */
          /*      printf("i=%d a=%s b=%s sav=%s\n",i, stra,strb,modelsav);*/
          /*scanf("%d",i);*/
-         if (strchr(strb,'*')) {  /**< Model includes a product V2+V1+V5*age+ V4+V3*age strb=V3*age */
+         if (strchr(strb,'*')) {  /**< Model includes a product V2+V1+V5*age+ V4+V3*age strb=V3*age OR double product with age strb=age*V6*V2 or V6*V2*age or V6*age*V2 */
-           cutl(strc,strd,strb,'*'); /**< k=1 strd*strc  Vm*Vn: strb=V3*age(input) strc=age strd=V3 ; V3*V2 strc=V2, strd=V3 */
+           cutl(strc,strd,strb,'*'); /**< k=1 strd*strc  Vm*Vn: strb=V3*age(input) strc=age strd=V3 ; V3*V2 strc=V2, strd=V3 OR strb=age*V6*V2 strc=V6*V2 strd=age OR c=V2*age OR c=age*V2  */
-           if (strcmp(strc,"age")==0) { /**< Model includes age: Vn*age */
+           if(strchr(strc,'*')) { /**< Model with age and DOUBLE product: allowed since 0.99r44, strc=V6*V2 or V2*age or age*V2, strd=age or V6 or V6   */
-             /* covar is not filled and then is empty */
+             Typevar[k]=3;  /* 3 for age and double product age*Vn*Vm varying of fixed */
-             cptcovprod--;
+             if(strstr(strc,"age")!=0) { /* It means that strc=V2*age or age*V2 and thus that strd=Vn */
-             cutl(stre,strb,strd,'V'); /* strd=V3(input): stre="3" */
+               cutl(stre,strf,strc,'*') ; /* strf=age or Vm, stre=Vm or age. If strc=V6*V2 then strf=V6 and stre=V2 */
-             Tvar[k]=atoi(stre);  /* V2+V1+V5*age+V4+V3*age Tvar[5]=3 ; V1+V2*age Tvar[2]=2; V1+V1*age Tvar[2]=1 */
+               strcpy(strc,strb); /* save strb(=age*Vn*Vm) into strc */
-             Typevar[k]=1;  /* 1 for age product */
+               /* We want strb=Vn*Vm */
-             cptcovage++; /* Counts the number of covariates which include age as a product */
+               if(strcmp(strf,"age")==0){ /* strf is "age" so that stre=Vm =V2 . */
-             Tage[cptcovage]=k;  /*  V2+V1+V4+V3*age Tvar[4]=3, Tage[1] = 4 or V1+V1*age Tvar[2]=1, Tage[1]=2 */
+                 strcpy(strb,strd);
-             /*printf("stre=%s ", stre);*/
+                 strcat(strb,"*");
-           } else if (strcmp(strd,"age")==0) { /* or age*Vn */
+                 strcat(strb,stre);
-             cptcovprod--;
+               }else{  /* strf=Vm  If strf=V6 then stre=V2 */
-             cutl(stre,strb,strc,'V');
+                 strcpy(strb,strf);
-             Tvar[k]=atoi(stre);
+                 strcat(strb,"*");
-             Typevar[k]=1;  /* 1 for age product */
+                 strcat(strb,stre);
-             cptcovage++;
+                 strcpy(strd,strb); /* in order for strd to not be "age"  for next test (will be Vn*Vm */
-             Tage[cptcovage]=k;
+               }
-           } else {  /* Age is not in the model product V2+V1+V1*V4+V3*age+V3*V2  strb=V3*V2*/
+               /* printf("DEBUG FIXED k=%d, Tage[k]=%d, Tvar[Tage[k]=%d,FixedV[Tvar[Tage[k]]]=%d\n",k,Tage[k],Tvar[Tage[k]],FixedV[Tvar[Tage[k]]]); */
-             /* loops on k1=1 (V3*V2) and k1=2 V4*V3 */
+               /* FixedV[Tvar[Tage[k]]]=0; /\* HERY not sure if V7*V4*age Fixed might not exist  yet*\/ */
-             cptcovn++;
+             }else{  /* strc=Vn*Vm (and strd=age) and should be strb=Vn*Vm but want to keep original strb double product  */
-             cptcovprodnoage++;k1++;
+               strcpy(stre,strb); /* save full b in stre */
+               strcpy(strb,strc); /* save short c in new short b for next block strb=Vn*Vm*/
+               strcpy(strf,strc); /* save short c in new short f */
+               cutl(strc,strd,strf,'*'); /* We get strd=Vn and strc=Vm for next block (strb=Vn*Vm)*/
+               /* strcpy(strc,stre);*/ /* save full e in c for future */
+             }
+             cptcovdageprod++; /* double product with age  Which product is it? */
+             /* strcpy(strb,strc);  /\* strb was age*V6*V2 or V6*V2*age or V6*age*V2 IS now V6*V2 or V2*age or age*V2 *\/ */
+             /* cutl(strc,strd,strb,'*'); /\* strd=  V6    or   V2     or    age and  strc=  V2 or    age or    V2 *\/ */
              cutl(stre,strb,strc,'V'); /* strc= Vn, stre is n; strb=V3*V2 stre=3 strc=*/
-             Tvar[k]=ncovcol+nqv+ntv+nqtv+k1; /* ncovcolt+k1; For model-covariate k tells which data-covariate to use but
+             n=atoi(stre);
-                                                 because this model-covariate is a construction we invent a new column
-                                                 which is after existing variables ncovcol+nqv+ntv+nqtv + k1
-                                                 If already ncovcol=4 and model= V2 + V1 + V1*V4 + age*V3 + V3*V2
-                                                 thus after V4 we invent V5 and V6 because age*V3 will be computed in 4
-                                                 Tvar[3=V1*V4]=4+1=5 Tvar[5=V3*V2]=4 + 2= 6, Tvar[4=age*V3]=3 etc */
-             /* Please remark that the new variables are model dependent */
-             /* If we have 4 variable but the model uses only 3, like in
-              * model= V1 + age*V1 + V2 + V3 + age*V2 + age*V3 + V1*V2 + V1*V3
-              *  k=     1     2       3   4     5        6        7       8
-              * Tvar[k]=1     1       2   3     2        3       (5       6) (and not 4 5 because of V4 missing)
-              * Tage[kk]    [1]= 2           [2]=5      [3]=6                  kk=1 to cptcovage=3
-              * Tvar[Tage[kk]][1]=2          [2]=2      [3]=3
-              */
-             Typevar[k]=2;  /* 2 for product */
              cutl(strc,strb,strd,'V'); /* strd was Vm, strc is m */
-             Tprod[k1]=k;  /* Tprod[1]=3(=V1*V4) for V2+V1+V1*V4+age*V3+V3*V2  */
+             m=atoi(strc);
-             Tposprod[k]=k1; /* Tposprod[3]=1, Tposprod[2]=5 */
+             cptcovage++; /* Counts the number of covariates which include age as a product */
-             Tvard[k1][1] =atoi(strc); /* m 1 for V1*/
+             Tage[cptcovage]=k; /* For age*V3*V2 gives the position in model of covariates associated with age Tage[1]=6 HERY too*/
-             Tvardk[k][1] =atoi(strc); /* m 1 for V1*/
+             if(existcomb[n][m] == 0){
-             Tvard[k1][2] =atoi(stre); /* n 4 for V4*/
+               /*  r /home/brouard/Documents/Recherches/REVES/Zachary/Zach-2022/Feinuo_Sun/Feinuo-threeway/femV12V15_3wayintNBe.imach */
-             Tvardk[k][2] =atoi(stre); /* n 4 for V4*/
+               printf("Warning in model combination V%d*V%d should exist in the model before adding V%d*V%d*age !\n",n,m,n,m);
-             k2=k2+2;  /* k2 is initialize to -1, We want to store the n and m in Vn*Vm at the end of Tvar */
+               fprintf(ficlog,"Warning in model combination V%d*V%d should exist in the model before adding V%d*V%d*age !\n",n,m,n,m);
-             /* Tvar[cptcovt+k2]=Tvard[k1][1]; /\* Tvar[(cptcovt=4+k2=1)=5]= 1 (V1) *\/ */
+               fflush(ficlog);
-             /* Tvar[cptcovt+k2+1]=Tvard[k1][2];  /\* Tvar[(cptcovt=4+(k2=1)+1)=6]= 4 (V4) *\/ */
+               k1++;  /* The combination Vn*Vm will be in the model so we create it at k1 */
-             /*ncovcol=4 and model=V2+V1+V1*V4+age*V3+V3*V2, Tvar[3]=5, Tvar[4]=6, cptcovt=5 */
+               k12++;
-             /*                     1  2   3      4     5 | Tvar[5+1)=1, Tvar[7]=2   */
+               existcomb[n][m]=k1;
-             if( FixedV[Tvardk[k][1]] == 0 && FixedV[Tvardk[k][2]] == 0){ /* If the product is a fixed covariate then we feed the new column with Vn*Vm */
+               existcomb[m][n]=k1;
-               for (i=1; i<=lastobs;i++){/* For fixed product */
+               Tvar[k]=ncovcol+nqv+ntv+nqtv+k1;
-               /* Computes the new covariate which is a product of
+               Tprod[k1]=k;  /* Tprod[1]=3(=V1*V4) for V2+V1+V1*V4+age*V3+V3*V2+ age*V6*V3 Gives the k position of the k1 double product Vn*Vm or age*Vn*Vm*/
-                  covar[n][i]* covar[m][i] and stores it at ncovol+k1 May not be defined */
+               Tposprod[k]=k1; /* Tposprod[3]=1, Tposprod[2]=5 Gives the k1 double product  Vn*Vm or age*Vn*Vm at the k position */
-               covar[ncovcolt+k1][i]=covar[atoi(stre)][i]*covar[atoi(strc)][i];
+               Tvard[k1][1] =m; /* m 1 for V1*/
+               Tvardk[k][1] =m; /* m 1 for V1*/
+               Tvard[k1][2] =n; /* n 4 for V4*/
+               Tvardk[k][2] =n; /* n 4 for V4*/
+ /*            Tvar[Tage[cptcovage]]=k1;*/ /* Tvar[6=age*V3*V2]=9 (new fixed covariate) */ /* We don't know about Fixed yet HERE */
+               if( FixedV[Tvardk[k][1]] == 0 && FixedV[Tvardk[k][2]] == 0){ /* If the product is a fixed covariate then we feed the new column with Vn*Vm */
+                 for (i=1; i<=lastobs;i++){/* For fixed product */
+                   /* Computes the new covariate which is a product of
+                      covar[n][i]* covar[m][i] and stores it at ncovol+k1 May not be defined */
+                   covar[ncovcolt+k1][i]=covar[atoi(stre)][i]*covar[atoi(strc)][i];
+                 }
+                 cptcovprodage++; /* Counting the number of fixed covariate with age */
+                 FixedV[ncovcolt+k12]=0; /* We expand Vn*Vm */
+                 k12++;
+                 FixedV[ncovcolt+k12]=0;
+               }else{ /*End of FixedV */
+                 cptcovprodvage++; /* Counting the number of varying covariate with age */
+                 FixedV[ncovcolt+k12]=1; /* We expand Vn*Vm */
+                 k12++;
+                 FixedV[ncovcolt+k12]=1;
+               }
+             }else{  /* k1 Vn*Vm already exists */
+               k11=existcomb[n][m];
+               Tposprod[k]=k11; /* OK */
+               Tvar[k]=Tvar[Tprod[k11]]; /* HERY */
+               Tvardk[k][1]=m;
+               Tvardk[k][2]=n;
+               if( FixedV[Tvardk[k][1]] == 0 && FixedV[Tvardk[k][2]] == 0){ /* If the product is a fixed covariate then we feed the new column with Vn*Vm */
+                 /*cptcovage++;*/ /* Counts the number of covariates which include age as a product */
+                 cptcovprodage++; /* Counting the number of fixed covariate with age */
+                 /*Tage[cptcovage]=k;*/ /* For age*V3*V2 Tage[1]=V3*V3=9 HERY too*/
+                 Tvar[Tage[cptcovage]]=k1;
+                 FixedV[ncovcolt+k12]=0; /* We expand Vn*Vm */
+                 k12++;
+                 FixedV[ncovcolt+k12]=0;
+               }else{ /* Already exists but time varying (and age) */
+                 /*cptcovage++;*/ /* Counts the number of covariates which include age as a product */
+                 /*Tage[cptcovage]=k;*/ /* For age*V3*V2 Tage[1]=V3*V3=9 HERY too*/
+                 /* Tvar[Tage[cptcovage]]=k1; */
+                 cptcovprodvage++;
+                 FixedV[ncovcolt+k12]=1; /* We expand Vn*Vm */
+                 k12++;
+                 FixedV[ncovcolt+k12]=1;
+               }
+             }
+             /* Tage[cptcovage]=k;  /\*  V2+V1+V4+V3*age Tvar[4]=3, Tage[1] = 4 or V1+V1*age Tvar[2]=1, Tage[1]=2 *\/ */
+             /* Tvar[k]=k11; /\* HERY *\/ */
+           } else {/* simple product strb=age*Vn so that c=Vn and d=age, or strb=Vn*age so that c=age and d=Vn, or b=Vn*Vm so that c=Vm and d=Vn */
+             cptcovprod++;
+             if (strcmp(strc,"age")==0) { /**< Model includes age: strb= Vn*age c=age d=Vn*/
+               /* covar is not filled and then is empty */
+               cutl(stre,strb,strd,'V'); /* strd=V3(input): stre="3" */
+               Tvar[k]=atoi(stre);  /* V2+V1+V5*age+V4+V3*age Tvar[5]=3 ; V1+V2*age Tvar[2]=2; V1+V1*age Tvar[2]=1 */
+               Typevar[k]=1;  /* 1 for age product */
+               cptcovage++; /* Counts the number of covariates which include age as a product */
+               Tage[cptcovage]=k;  /*  V2+V1+V4+V3*age Tvar[4]=3, Tage[1] = 4 or V1+V1*age Tvar[2]=1, Tage[1]=2 */
+               if( FixedV[Tvar[k]] == 0){
+                 cptcovprodage++; /* Counting the number of fixed covariate with age */
+               }else{
+                 cptcovprodvage++; /* Counting the number of fixedvarying covariate with age */
+               }
+               /*printf("stre=%s ", stre);*/
+             } else if (strcmp(strd,"age")==0) { /* strb= age*Vn c=Vn */
+               cutl(stre,strb,strc,'V');
+               Tvar[k]=atoi(stre);
+               Typevar[k]=1;  /* 1 for age product */
+               cptcovage++;
+               Tage[cptcovage]=k;
+               if( FixedV[Tvar[k]] == 0){
+                 cptcovprodage++; /* Counting the number of fixed covariate with age */
+               }else{
+                 cptcovprodvage++; /* Counting the number of fixedvarying covariate with age */
                }
-             } /*End of FixedV */
+             }else{ /*  for product Vn*Vm */
-           } /* End age is not in the model */
+               Typevar[k]=2;  /* 2 for product Vn*Vm */
-         } /* End if model includes a product */
+               cutl(stre,strb,strc,'V'); /* strc= Vn, stre is n; strb=V3*V2 stre=3 strc=*/
-         else { /* not a product */
+               n=atoi(stre);
+               cutl(strc,strb,strd,'V'); /* strd was Vm, strc is m */
+               m=atoi(strc);
+               k1++;
+               cptcovprodnoage++;
+               if(existcomb[n][m] != 0 || existcomb[m][n] != 0){
+                 printf("Warning in model combination V%d*V%d already exists in the model in position k1=%d!\n",n,m,existcomb[n][m]);
+                 fprintf(ficlog,"Warning in model combination V%d*V%d already exists in the model in position k1=%d!\n",n,m,existcomb[n][m]);
+                 fflush(ficlog);
+                 k11=existcomb[n][m];
+                 Tvar[k]=ncovcol+nqv+ntv+nqtv+k11;
+                 Tposprod[k]=k11;
+                 Tprod[k11]=k;
+                 Tvardk[k][1] =m; /* m 1 for V1*/
+                 /* Tvard[k11][1] =m; /\* n 4 for V4*\/ */
+                 Tvardk[k][2] =n; /* n 4 for V4*/
+                 /* Tvard[k11][2] =n; /\* n 4 for V4*\/ */
+               }else{ /* combination Vn*Vm doesn't exist we create it (no age)*/
+                 existcomb[n][m]=k1;
+                 existcomb[m][n]=k1;
+                 Tvar[k]=ncovcol+nqv+ntv+nqtv+k1; /* ncovcolt+k1; For model-covariate k tells which data-covariate to use but
+                                                     because this model-covariate is a construction we invent a new column
+                                                     which is after existing variables ncovcol+nqv+ntv+nqtv + k1
+                                                     If already ncovcol=4 and model= V2 + V1 + V1*V4 + age*V3 + V3*V2
+                                                     thus after V4 we invent V5 and V6 because age*V3 will be computed in 4
+                                                     Tvar[3=V1*V4]=4+1=5 Tvar[5=V3*V2]=4 + 2= 6, Tvar[4=age*V3]=3 etc */
+                 /* Please remark that the new variables are model dependent */
+                 /* If we have 4 variable but the model uses only 3, like in
+                  * model= V1 + age*V1 + V2 + V3 + age*V2 + age*V3 + V1*V2 + V1*V3
+                  *  k=     1     2      3   4     5        6        7       8
+                  * Tvar[k]=1     1       2   3     2        3       (5       6) (and not 4 5 because of V4 missing)
+                  * Tage[kk]    [1]= 2           [2]=5      [3]=6                  kk=1 to cptcovage=3
+                  * Tvar[Tage[kk]][1]=2          [2]=2      [3]=3
+                  */
+                 /* We need to feed some variables like TvarVV, but later on next loop because of ncovv (k2) is not correct */
+                 Tprod[k1]=k;  /* Tprod[1]=3(=V1*V4) for V2+V1+V1*V4+age*V3+V3*V2 +V6*V2*age  */
+                 Tposprod[k]=k1; /* Tposprod[3]=1, Tposprod[2]=5 */
+                 Tvard[k1][1] =m; /* m 1 for V1*/
+                 Tvardk[k][1] =m; /* m 1 for V1*/
+                 Tvard[k1][2] =n; /* n 4 for V4*/
+                 Tvardk[k][2] =n; /* n 4 for V4*/
+                 k2=k2+2;  /* k2 is initialize to -1, We want to store the n and m in Vn*Vm at the end of Tvar */
+                 /* Tvar[cptcovt+k2]=Tvard[k1][1]; /\* Tvar[(cptcovt=4+k2=1)=5]= 1 (V1) *\/ */
+                 /* Tvar[cptcovt+k2+1]=Tvard[k1][2];  /\* Tvar[(cptcovt=4+(k2=1)+1)=6]= 4 (V4) *\/ */
+                 /*ncovcol=4 and model=V2+V1+V1*V4+age*V3+V3*V2, Tvar[3]=5, Tvar[4]=6, cptcovt=5 */
+                 /*                     1  2   3      4     5 | Tvar[5+1)=1, Tvar[7]=2   */
+                 if( FixedV[Tvardk[k][1]] == 0 && FixedV[Tvardk[k][2]] == 0){ /* If the product is a fixed covariate then we feed the new column with Vn*Vm */
+                   for (i=1; i<=lastobs;i++){/* For fixed product */
+                     /* Computes the new covariate which is a product of
+                        covar[n][i]* covar[m][i] and stores it at ncovol+k1 May not be defined */
+                     covar[ncovcolt+k1][i]=covar[atoi(stre)][i]*covar[atoi(strc)][i];
+                   }
+                   /* TvarVV[k2]=n; */
+                   /* FixedV[ncovcolt+k2]=0; /\* or FixedV[Tvar[k]]=0; FixedV[TvarVV[ncovv]]=0 HERE *\/ */
+                   /* TvarVV[k2+1]=m; */
+                   /* FixedV[ncovcolt+k2]=0; /\* or FixedV[Tvar[k]]=0; FixedV[TvarVV[ncovv]]=0 HERE *\/ */
+                 }else{ /* not FixedV */
+                   /* TvarVV[k2]=n; */
+                   /* FixedV[ncovcolt+k2]=0; /\* or FixedV[Tvar[k]]=0; FixedV[TvarVV[ncovv]]=0 HERE *\/ */
+                   /* TvarVV[k2+1]=m; */
+                   /* FixedV[ncovcolt+k2]=0; /\* or FixedV[Tvar[k]]=0; FixedV[TvarVV[ncovv]]=0 HERE *\/ */
+                 }
+               }  /* End of creation of Vn*Vm if not created by age*Vn*Vm earlier  */
+             } /*  End of product Vn*Vm */
+           } /* End of age*double product or simple product */
+         }else { /* not a product */
            /*printf("d=%s c=%s b=%s\n", strd,strc,strb);*/
            /*  scanf("%d",i);*/
            cutl(strd,strc,strb,'V');
- Line 11239  int decodemodel( char model[], int lasto
+ Line 13313  int decodemodel( char model[], int lasto
                                  /*printf("a=%s b=%s sav=%s\n", stra,strb,modelsav);
                                    scanf("%d",i);*/
        } /* end of loop + on total covariates */
      } /* end if strlen(modelsave == 0) age*age might exist */
    } /* end if strlen(model == 0) */
+   cptcovs=cptcovt - cptcovdageprod - cptcovprod;/**<  Number of simple covariates V1 +V1*age +V3 +V3*V4 +age*age + age*v4*V3=> V1 + V3 =4+1-3=2  */
    /*The number n of Vn is stored in Tvar. cptcovage =number of age covariate. Tage gives the position of age. cptcovprod= number of products.
      If model=V1+V1*age then Tvar[1]=1 Tvar[2]=1 cptcovage=1 Tage[1]=2 cptcovprod=0*/
- Line 11267  int decodemodel( char model[], int lasto
+ Line 13344  int decodemodel( char model[], int lasto
    /* Tvar[k] is the value n of Vn with n varying for 1 to nvcol, or p  Vp=Vn*Vm for product */
          /* Computing effective variables, ie used by the model, that is from the cptcovt variables */
    printf("Model=1+age+%s\n\
- Typevar: 0 for simple covariate (dummy, quantitative, fixed or varying), 1 for age product, 2 for  product \n\
+ Typevar: 0 for simple covariate (dummy, quantitative, fixed or varying), 1 for age product, 2 for  product, 3 for double product with age \n\
  Fixed[k] 0=fixed (product or simple), 1 varying, 2 fixed with age product, 3 varying with age product \n\
  Dummy[k] 0=dummy (0 1), 1 quantitative (single or product without age), 2 dummy with age product, 3 quant with age product\n",model);
    fprintf(ficlog,"Model=1+age+%s\n\
- Typevar: 0 for simple covariate (dummy, quantitative, fixed or varying), 1 for age product, 2 for  product \n\
+ Typevar: 0 for simple covariate (dummy, quantitative, fixed or varying), 1 for age product, 2 for  product, 3 for double product with age  \n\
  Fixed[k] 0=fixed (product or simple), 1 varying, 2 fixed with age product, 3 varying with age product \n\
  Dummy[k] 0=dummy (0 1), 1 quantitative (single or product without age), 2 dummy with age product, 3 quant with age product\n",model);
    for(k=-1;k<=NCOVMAX; k++){ Fixed[k]=0; Dummy[k]=0;}
    for(k=1;k<=NCOVMAX; k++){TvarFind[k]=0; TvarVind[k]=0;}
-   for(k=1, ncovf=0, nsd=0, nsq=0, ncovv=0, ncova=0, ncoveff=0, nqfveff=0, ntveff=0, nqtveff=0, ncovvt=0;k<=cptcovt; k++){ /* or cptocvt loop on k from model */
+   /* Second loop for calculating  Fixed[k], Dummy[k]*/
+   for(k=1, ncovf=0, nsd=0, nsq=0, ncovv=0,ncovva=0,ncovvta=0, ncova=0, ncoveff=0, nqfveff=0, ntveff=0, nqtveff=0, ncovvt=0;k<=cptcovt; k++){ /* or cptocvt loop on k from model */
      if (Tvar[k] <=ncovcol && Typevar[k]==0 ){ /* Simple fixed dummy (<=ncovcol) covariates */
        Fixed[k]= 0;
        Dummy[k]= 0;
- Line 11292  Dummy[k] 0=dummy (0 1), 1 quantitative (
+ Line 13374  Dummy[k] 0=dummy (0 1), 1 quantitative (
        TvarFD[ncoveff]=Tvar[k]; /* TvarFD[1]=V1 in V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */
        TvarFDind[ncoveff]=k; /* TvarFDind[1]=9 in V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */
      /* }else if( Tvar[k] <=ncovcol &&  Typevar[k]==2){ /\* Product of fixed dummy (<=ncovcol) covariates For a fixed product k is higher than ncovcol *\/ */
-     }else if( Tposprod[k]>0  &&  Typevar[k]==2 && FixedV[Tvardk[k][1]] == 0 && FixedV[Tvardk[k][2]] == 0){ /* Needs a fixed product Product of fixed dummy (<=ncovcol) covariates For a fixed product k is higher than ncovcol */
-       Fixed[k]= 0;
-       Dummy[k]= 0;
-       ncoveff++;
-       ncovf++;
-       modell[k].maintype= FTYPE;
-       TvarF[ncovf]=Tvar[k];
-       /* TnsdVar[Tvar[k]]=nsd; */ /* To be done */
-       TvarFind[ncovf]=k;
-       TvarFD[ncoveff]=Tvar[k]; /* TvarFD[1]=V1 in V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */
-       TvarFDind[ncoveff]=k; /* TvarFDind[1]=9 in V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */
      }else if( Tvar[k] <=ncovcol+nqv && Typevar[k]==0){/* Remind that product Vn*Vm are added in k Only simple fixed quantitative variable */
        Fixed[k]= 0;
        Dummy[k]= 1;
- Line 11364  Dummy[k] 0=dummy (0 1), 1 quantitative (
+ Line 13435  Dummy[k] 0=dummy (0 1), 1 quantitative (
        TvarVQind[nqtveff]=k; /* TvarVQind[1]=1 in V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */ /* Only simple time varying quantitative variable */
        TmodelInvQind[nqtveff]=Tvar[k]- ncovcol-nqv-ntv;/* Only simple time varying quantitative variable */
        /* Tmodeliqind[k]=nqtveff;/\* Only simple time varying quantitative variable *\/ */
-       /* printf("Quasi TmodelQind[%d]=%d,Tvar[TmodelQind[%d]]=V%d, ncovcol=%d, nqv=%d, ntv=%d,Tvar[k]- ncovcol-nqv-ntv=%d\n",nqtveff,k,nqtveff,Tvar[k], ncovcol, nqv, ntv, Tvar[k]- ncovcol-nqv-ntv); */
+       /* printf("Quasi TmodelQind[%d]=%d,Tvar[TmodelQind[%d]]=V%d, ncovcol=%d, nqv=%d, ntv=%Ad,Tvar[k]- ncovcol-nqv-ntv=%d\n",nqtveff,k,nqtveff,Tvar[k], ncovcol, nqv, ntv, Tvar[k]- ncovcol-nqv-ntv); */
        /* printf("Quasi TmodelInvQind[%d]=%d\n",k,Tvar[k]- ncovcol-nqv-ntv); */
      }else if (Typevar[k] == 1) {  /* product with age */
        ncova++;
        TvarA[ncova]=Tvar[k];
        TvarAind[ncova]=k;
+       /** Fixed[k] 0=fixed, 1 varying, 2 fixed with age product, 3 varying with age product */
+       /** Dummy[k] 0=dummy (0 1), 1 quantitative (single or product without age), 2 dummy with age product, 3 quant with age product */
        if (Tvar[k] <=ncovcol ){ /* Product age with fixed dummy covariatee */
          Fixed[k]= 2;
          Dummy[k]= 2;
          modell[k].maintype= ATYPE;
          modell[k].subtype= APFD;
+         ncovta++;
+         TvarAVVA[ncovta]=Tvar[k]; /*  (2)age*V3 */
+         TvarAVVAind[ncovta]=k;
          /* ncoveff++; */
        }else if( Tvar[k] <=ncovcol+nqv) { /* Remind that product Vn*Vm are added in k*/
          Fixed[k]= 2;
          Dummy[k]= 3;
          modell[k].maintype= ATYPE;
          modell[k].subtype= APFQ;                /*      Product age * fixed quantitative */
+         ncovta++;
+         TvarAVVA[ncovta]=Tvar[k]; /*   */
+         TvarAVVAind[ncovta]=k;
          /* nqfveff++;  /\* Only simple fixed quantitative variable *\/ */
        }else if( Tvar[k] <=ncovcol+nqv+ntv ){
          Fixed[k]= 3;
          Dummy[k]= 2;
          modell[k].maintype= ATYPE;
          modell[k].subtype= APVD;                /*      Product age * varying dummy */
+         ncovva++;
+         TvarVVA[ncovva]=Tvar[k]; /*  (1)+age*V6 + (2)age*V7 */
+         TvarVVAind[ncovva]=k;
+         ncovta++;
+         TvarAVVA[ncovta]=Tvar[k]; /*   */
+         TvarAVVAind[ncovta]=k;
          /* ntveff++; /\* Only simple time varying dummy variable *\/ */
        }else if( Tvar[k] <=ncovcol+nqv+ntv+nqtv){
          Fixed[k]= 3;
          Dummy[k]= 3;
          modell[k].maintype= ATYPE;
          modell[k].subtype= APVQ;                /*      Product age * varying quantitative */
+         ncovva++;
+         TvarVVA[ncovva]=Tvar[k]; /*   */
+         TvarVVAind[ncovva]=k;
+         ncovta++;
+         TvarAVVA[ncovta]=Tvar[k]; /*  (1)+age*V6 + (2)age*V7 */
+         TvarAVVAind[ncovta]=k;
          /* nqtveff++;/\* Only simple time varying quantitative variable *\/ */
        }
-     }else if (Typevar[k] == 2) {  /* product Vn * Vm without age, V1+V3+age*V1+age*V3+V1*V3 looking at V1*V3, Typevar={0, 0, 1, 1, 2}, k=5, V1 is fixed, V3 is timevary, V5 is a product  */
+     }else if( Tposprod[k]>0  &&  Typevar[k]==2){  /* Detects if fixed product no age Vm*Vn */
+       printf("MEMORY ERRORR k=%d  Tposprod[k]=%d, Typevar[k]=%d\n ",k, Tposprod[k], Typevar[k]);
+       if(FixedV[Tvardk[k][1]] == 0 && FixedV[Tvardk[k][2]] == 0){ /* Needs a fixed product Product of fixed dummy (<=ncovcol) covariates For a fixed product k is higher than ncovcol V3*V2 */
+       printf("MEMORY ERRORR k=%d Tvardk[k][1]=%d, Tvardk[k][2]=%d, FixedV[Tvardk[k][1]]=%d,FixedV[Tvardk[k][2]]=%d\n ",k,Tvardk[k][1],Tvardk[k][2],FixedV[Tvardk[k][1]],FixedV[Tvardk[k][2]]);
+         Fixed[k]= 0;
+         Dummy[k]= 0;
+         ncoveff++;
+         ncovf++;
+         /* ncovv++; */
+         /* TvarVV[ncovv]=Tvardk[k][1]; */
+         /* FixedV[ncovcolt+ncovv]=0; /\* or FixedV[TvarVV[ncovv]]=0 HERE *\/ */
+         /* ncovv++; */
+         /* TvarVV[ncovv]=Tvardk[k][2]; */
+         /* FixedV[ncovcolt+ncovv]=0; /\* or FixedV[TvarVV[ncovv]]=0 HERE *\/ */
+         modell[k].maintype= FTYPE;
+         TvarF[ncovf]=Tvar[k];
+         /* TnsdVar[Tvar[k]]=nsd; */ /* To be done */
+         TvarFind[ncovf]=k;
+         TvarFD[ncoveff]=Tvar[k]; /* TvarFD[1]=V1 in V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */
+         TvarFDind[ncoveff]=k; /* TvarFDind[1]=9 in V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */
+       }else{/* product varying Vn * Vm without age, V1+V3+age*V1+age*V3+V1*V3 looking at V1*V3, Typevar={0, 0, 1, 1, 2}, k=5, V1 is fixed, V3 is timevary, V5 is a product  */
+         /*#  ID           V1     V2          weight               birth   death   1st    s1      V3      V4      V5       2nd  s2 */
+         /* model V1+V3+age*V1+age*V3+V1*V3 + V1*V3*age*/
+         /*  Tvar={1, 3, 1, 3, 6, 6}, the 6 comes from the fact that there are already V1, V2, V3, V4, V5 native covariates */
+         k1=Tposprod[k];  /* Position in the products of product k, Tposprod={0, 0, 0, 0, 1, 1} k1=1 first product but second time varying because of V3 */
+         ncovvt++;
+         TvarVV[ncovvt]=Tvard[k1][1];  /*  TvarVV[2]=V1 (because TvarVV[1] was V3, first time varying covariates */
+         TvarVVind[ncovvt]=k;  /*  TvarVVind[2]=5 (because TvarVVind[2] was V1*V3 at position 5 */
+         ncovvt++;
+         TvarVV[ncovvt]=Tvard[k1][2];  /*  TvarVV[3]=V3 */
+         TvarVVind[ncovvt]=k;  /*  TvarVVind[2]=5 (because TvarVVind[2] was V1*V3 at position 5 */
+         /** Fixed[k] 0=fixed, 1 varying, 2 fixed with age product, 3 varying with age product */
+         /** Dummy[k] 0=dummy (0 1), 1 quantitative (single or product without age), 2 dummy with age product, 3 quant with age product */
+         if(Tvard[k1][1] <=ncovcol){ /* Vn is dummy fixed, (Tvard[1][1]=V1), (Tvard[1][1]=V3 time varying) */
+           if(Tvard[k1][2] <=ncovcol){ /* Vm is dummy fixed */
+             Fixed[k]= 1;
+             Dummy[k]= 0;
+             modell[k].maintype= FTYPE;
+             modell[k].subtype= FPDD;            /*      Product fixed dummy * fixed dummy */
+             ncovf++; /* Fixed variables without age */
+             TvarF[ncovf]=Tvar[k];
+             TvarFind[ncovf]=k;
+           }else if(Tvard[k1][2] <=ncovcol+nqv){ /* Vm is quanti fixed */
+             Fixed[k]= 0;  /* Fixed product */
+             Dummy[k]= 1;
+             modell[k].maintype= FTYPE;
+             modell[k].subtype= FPDQ;            /*      Product fixed dummy * fixed quantitative */
+             ncovf++; /* Varying variables without age */
+             TvarF[ncovf]=Tvar[k];
+             TvarFind[ncovf]=k;
+           }else if(Tvard[k1][2] <=ncovcol+nqv+ntv){ /* Vm is a time varying dummy covariate */
+             Fixed[k]= 1;
+             Dummy[k]= 0;
+             modell[k].maintype= VTYPE;
+             modell[k].subtype= VPDD;            /*      Product fixed dummy * varying dummy */
+             ncovv++; /* Varying variables without age */
+             TvarV[ncovv]=Tvar[k];  /* TvarV[1]=Tvar[5]=5 because there is a V4 */
+             TvarVind[ncovv]=k;/* TvarVind[1]=5 */
+           }else if(Tvard[k1][2] <=ncovcol+nqv+ntv+nqtv){ /* Vm is a time varying quantitative covariate */
+             Fixed[k]= 1;
+             Dummy[k]= 1;
+             modell[k].maintype= VTYPE;
+             modell[k].subtype= VPDQ;            /*      Product fixed dummy * varying quantitative */
+             ncovv++; /* Varying variables without age */
+             TvarV[ncovv]=Tvar[k];
+             TvarVind[ncovv]=k;
+           }
+         }else if(Tvard[k1][1] <=ncovcol+nqv){ /* Vn is fixed quanti  */
+           if(Tvard[k1][2] <=ncovcol){ /* Vm is fixed dummy */
+             Fixed[k]= 0;  /*  Fixed product */
+             Dummy[k]= 1;
+             modell[k].maintype= FTYPE;
+             modell[k].subtype= FPDQ;            /*      Product fixed quantitative * fixed dummy */
+             ncovf++; /* Fixed variables without age */
+             TvarF[ncovf]=Tvar[k];
+             TvarFind[ncovf]=k;
+           }else if(Tvard[k1][2] <=ncovcol+nqv+ntv){ /* Vm is time varying */
+             Fixed[k]= 1;
+             Dummy[k]= 1;
+             modell[k].maintype= VTYPE;
+             modell[k].subtype= VPDQ;            /*      Product fixed quantitative * varying dummy */
+             ncovv++; /* Varying variables without age */
+             TvarV[ncovv]=Tvar[k];
+             TvarVind[ncovv]=k;
+           }else if(Tvard[k1][2] <=ncovcol+nqv+ntv+nqtv){ /* Vm is time varying quanti */
+             Fixed[k]= 1;
+             Dummy[k]= 1;
+             modell[k].maintype= VTYPE;
+             modell[k].subtype= VPQQ;            /*      Product fixed quantitative * varying quantitative */
+             ncovv++; /* Varying variables without age */
+             TvarV[ncovv]=Tvar[k];
+             TvarVind[ncovv]=k;
+             ncovv++; /* Varying variables without age */
+             TvarV[ncovv]=Tvar[k];
+             TvarVind[ncovv]=k;
+           }
+         }else if(Tvard[k1][1] <=ncovcol+nqv+ntv){ /* Vn is time varying dummy */
+           if(Tvard[k1][2] <=ncovcol){
+             Fixed[k]= 1;
+             Dummy[k]= 1;
+             modell[k].maintype= VTYPE;
+             modell[k].subtype= VPDD;            /*      Product time varying dummy * fixed dummy */
+             ncovv++; /* Varying variables without age */
+             TvarV[ncovv]=Tvar[k];
+             TvarVind[ncovv]=k;
+           }else if(Tvard[k1][2] <=ncovcol+nqv){
+             Fixed[k]= 1;
+             Dummy[k]= 1;
+             modell[k].maintype= VTYPE;
+             modell[k].subtype= VPDQ;            /*      Product time varying dummy * fixed quantitative */
+             ncovv++; /* Varying variables without age */
+             TvarV[ncovv]=Tvar[k];
+             TvarVind[ncovv]=k;
+           }else if(Tvard[k1][2] <=ncovcol+nqv+ntv){
+             Fixed[k]= 1;
+             Dummy[k]= 0;
+             modell[k].maintype= VTYPE;
+             modell[k].subtype= VPDD;            /*      Product time varying dummy * time varying dummy */
+             ncovv++; /* Varying variables without age */
+             TvarV[ncovv]=Tvar[k];
+             TvarVind[ncovv]=k;
+           }else if(Tvard[k1][2] <=ncovcol+nqv+ntv+nqtv){
+             Fixed[k]= 1;
+             Dummy[k]= 1;
+             modell[k].maintype= VTYPE;
+             modell[k].subtype= VPDQ;            /*      Product time varying dummy * time varying quantitative */
+             ncovv++; /* Varying variables without age */
+             TvarV[ncovv]=Tvar[k];
+             TvarVind[ncovv]=k;
+           }
+         }else if(Tvard[k1][1] <=ncovcol+nqv+ntv+nqtv){ /* Vn is time varying quanti */
+           if(Tvard[k1][2] <=ncovcol){
+             Fixed[k]= 1;
+             Dummy[k]= 1;
+             modell[k].maintype= VTYPE;
+             modell[k].subtype= VPDQ;            /*      Product time varying quantitative * fixed dummy */
+             ncovv++; /* Varying variables without age */
+             TvarV[ncovv]=Tvar[k];
+             TvarVind[ncovv]=k;
+           }else if(Tvard[k1][2] <=ncovcol+nqv){
+             Fixed[k]= 1;
+             Dummy[k]= 1;
+             modell[k].maintype= VTYPE;
+             modell[k].subtype= VPQQ;            /*      Product time varying quantitative * fixed quantitative */
+             ncovv++; /* Varying variables without age */
+             TvarV[ncovv]=Tvar[k];
+             TvarVind[ncovv]=k;
+           }else if(Tvard[k1][2] <=ncovcol+nqv+ntv){
+             Fixed[k]= 1;
+             Dummy[k]= 1;
+             modell[k].maintype= VTYPE;
+             modell[k].subtype= VPDQ;            /*      Product time varying quantitative * time varying dummy */
+             ncovv++; /* Varying variables without age */
+             TvarV[ncovv]=Tvar[k];
+             TvarVind[ncovv]=k;
+           }else if(Tvard[k1][2] <=ncovcol+nqv+ntv+nqtv){
+             Fixed[k]= 1;
+             Dummy[k]= 1;
+             modell[k].maintype= VTYPE;
+             modell[k].subtype= VPQQ;            /*      Product time varying quantitative * time varying quantitative */
+             ncovv++; /* Varying variables without age */
+             TvarV[ncovv]=Tvar[k];
+             TvarVind[ncovv]=k;
+           }
+         }else{
+           printf("Error unknown type of covariate: Tvard[%d][1]=%d,Tvard[%d][2]=%d\n",k1,Tvard[k1][1],k1,Tvard[k1][2]);
+           fprintf(ficlog,"Error unknown type of covariate: Tvard[%d][1]=%d,Tvard[%d][2]=%d\n",k1,Tvard[k1][1],k1,Tvard[k1][2]);
+         } /*end k1*/
+       }
+     }else if(Typevar[k] == 3){  /* product Vn * Vm with age, V1+V3+age*V1+age*V3+V1*V3 looking at V1*V3, Typevar={0, 0, 1, 1, 2}, k=5, V1 is fixed, V3 is timevary, V5 is a product  */
        /*#  ID           V1     V2          weight               birth   death   1st    s1      V3      V4      V5       2nd  s2 */
-       /* model V1+V3+age*V1+age*V3+V1*V3 */
+       /* model V1+V3+age*V1+age*V3+V1*V3 + V1*V3*age*/
-       /*  Tvar={1, 3, 1, 3, 6}, the 6 comes from the fact that there are already V1, V2, V3, V4, V5 native covariates */
+       /*  Tvar={1, 3, 1, 3, 6, 6}, the 6 comes from the fact that there are already V1, V2, V3, V4, V5 native covariates */
-       k1=Tposprod[k];  /* Position in the products of product k, Tposprod={0, 0, 0, 0, 1} k1=1 first product but second time varying because of V3 */
+       k1=Tposprod[k];  /* Position in the products of product k, Tposprod={0, 0, 0, 0, 1, 1} k1=1 first product but second time varying because of V3 */
-       ncovvt++;
+       ncova++;
-       TvarVV[ncovvt]=Tvard[k1][1];  /*  TvarVV[2]=V1 (because TvarVV[1] was V3, first time varying covariates */
+       TvarA[ncova]=Tvard[k1][1];  /*  TvarVV[2]=V1 (because TvarVV[1] was V3, first time varying covariates */
-       TvarVVind[ncovvt]=k;  /*  TvarVVind[2]=5 (because TvarVVind[2] was V1*V3 at position 5 */
+       TvarAind[ncova]=k;  /*  TvarVVind[2]=5 (because TvarVVind[2] was V1*V3 at position 5 */
-       ncovvt++;
+       ncova++;
-       TvarVV[ncovvt]=Tvard[k1][2];  /*  TvarVV[3]=V3 */
+       TvarA[ncova]=Tvard[k1][2];  /*  TvarVV[3]=V3 */
-       TvarVVind[ncovvt]=k;  /*  TvarVVind[2]=5 (because TvarVVind[2] was V1*V3 at position 5 */
+       TvarAind[ncova]=k;  /*  TvarVVind[2]=5 (because TvarVVind[2] was V1*V3 at position 5 */
+       /** Fixed[k] 0=fixed, 1 varying, 2 fixed with age product, 3 varying with age product */
+       /** Dummy[k] 0=dummy (0 1), 1 quantitative (single or product without age), 2 dummy with age product, 3 quant with age product */
+       if( FixedV[Tvardk[k][1]] == 0 && FixedV[Tvardk[k][2]] == 0){
+         ncovta++;
+         TvarAVVA[ncovta]=Tvard[k1][1]; /*   age*V6*V3 +age*V7*V3 + age*V6*V4 +age*V7*V4 */
+         TvarAVVAind[ncovta]=k;
+         ncovta++;
+         TvarAVVA[ncovta]=Tvard[k1][2]; /*   age*V6*V3 +age*V7*V3 + age*V6*V4 +age*V7*V4 */
+         TvarAVVAind[ncovta]=k;
+       }else{
+         ncovva++;  /* HERY  reached */
+         TvarVVA[ncovva]=Tvard[k1][1]; /*  age*V6*V3 +age*V7*V3 + age*V6*V4 +age*V7*V4  */
+         TvarVVAind[ncovva]=k;
+         ncovva++;
+         TvarVVA[ncovva]=Tvard[k1][2]; /*   */
+         TvarVVAind[ncovva]=k;
+         ncovta++;
+         TvarAVVA[ncovta]=Tvard[k1][1]; /*   age*V6*V3 +age*V7*V3 + age*V6*V4 +age*V7*V4 */
+         TvarAVVAind[ncovta]=k;
+         ncovta++;
+         TvarAVVA[ncovta]=Tvard[k1][2]; /*   age*V6*V3 +age*V7*V3 + age*V6*V4 +age*V7*V4 */
+         TvarAVVAind[ncovta]=k;
+       }
        if(Tvard[k1][1] <=ncovcol){ /* Vn is dummy fixed, (Tvard[1][1]=V1), (Tvard[1][1]=V3 time varying) */
          if(Tvard[k1][2] <=ncovcol){ /* Vm is dummy fixed */
-           Fixed[k]= 1;
+           Fixed[k]= 2;
-           Dummy[k]= 0;
+           Dummy[k]= 2;
            modell[k].maintype= FTYPE;
            modell[k].subtype= FPDD;              /*      Product fixed dummy * fixed dummy */
-           ncovf++; /* Fixed variables without age */
+           /* TvarF[ncova]=Tvar[k];   /\* Problem to solve *\/ */
-           TvarF[ncovf]=Tvar[k];
+           /* TvarFind[ncova]=k; */
-           TvarFind[ncovf]=k;
          }else if(Tvard[k1][2] <=ncovcol+nqv){ /* Vm is quanti fixed */
-           Fixed[k]= 0;  /* Fixed product */
+           Fixed[k]= 2;  /* Fixed product */
-           Dummy[k]= 1;
+           Dummy[k]= 3;
            modell[k].maintype= FTYPE;
            modell[k].subtype= FPDQ;              /*      Product fixed dummy * fixed quantitative */
-           ncovf++; /* Varying variables without age */
+           /* TvarF[ncova]=Tvar[k]; */
-           TvarF[ncovf]=Tvar[k];
+           /* TvarFind[ncova]=k; */
-           TvarFind[ncovf]=k;
          }else if(Tvard[k1][2] <=ncovcol+nqv+ntv){ /* Vm is a time varying dummy covariate */
-           Fixed[k]= 1;
+           Fixed[k]= 3;
-           Dummy[k]= 0;
+           Dummy[k]= 2;
            modell[k].maintype= VTYPE;
            modell[k].subtype= VPDD;              /*      Product fixed dummy * varying dummy */
-           ncovv++; /* Varying variables without age */
+           TvarV[ncova]=Tvar[k];  /* TvarV[1]=Tvar[5]=5 because there is a V4 */
-           TvarV[ncovv]=Tvar[k];  /* TvarV[1]=Tvar[5]=5 because there is a V4 */
+           TvarVind[ncova]=k;/* TvarVind[1]=5 */
-           TvarVind[ncovv]=k;/* TvarVind[1]=5 */
          }else if(Tvard[k1][2] <=ncovcol+nqv+ntv+nqtv){ /* Vm is a time varying quantitative covariate */
-           Fixed[k]= 1;
+           Fixed[k]= 3;
-           Dummy[k]= 1;
+           Dummy[k]= 3;
            modell[k].maintype= VTYPE;
            modell[k].subtype= VPDQ;              /*      Product fixed dummy * varying quantitative */
-           ncovv++; /* Varying variables without age */
+           /* ncovv++; /\* Varying variables without age *\/ */
-           TvarV[ncovv]=Tvar[k];
+           /* TvarV[ncovv]=Tvar[k]; */
-           TvarVind[ncovv]=k;
+           /* TvarVind[ncovv]=k; */
          }
        }else if(Tvard[k1][1] <=ncovcol+nqv){ /* Vn is fixed quanti  */
          if(Tvard[k1][2] <=ncovcol){ /* Vm is fixed dummy */
-           Fixed[k]= 0;  /*  Fixed product */
+           Fixed[k]= 2;  /*  Fixed product */
-           Dummy[k]= 1;
+           Dummy[k]= 2;
            modell[k].maintype= FTYPE;
            modell[k].subtype= FPDQ;              /*      Product fixed quantitative * fixed dummy */
-           ncovf++; /* Fixed variables without age */
+           /* ncova++; /\* Fixed variables with age *\/ */
-           TvarF[ncovf]=Tvar[k];
+           /* TvarF[ncovf]=Tvar[k]; */
-           TvarFind[ncovf]=k;
+           /* TvarFind[ncovf]=k; */
          }else if(Tvard[k1][2] <=ncovcol+nqv+ntv){ /* Vm is time varying */
-           Fixed[k]= 1;
+           Fixed[k]= 2;
-           Dummy[k]= 1;
+           Dummy[k]= 3;
            modell[k].maintype= VTYPE;
            modell[k].subtype= VPDQ;              /*      Product fixed quantitative * varying dummy */
-           ncovv++; /* Varying variables without age */
+           /* ncova++; /\* Varying variables with age *\/ */
-           TvarV[ncovv]=Tvar[k];
+           /* TvarV[ncova]=Tvar[k]; */
-           TvarVind[ncovv]=k;
+           /* TvarVind[ncova]=k; */
          }else if(Tvard[k1][2] <=ncovcol+nqv+ntv+nqtv){ /* Vm is time varying quanti */
-           Fixed[k]= 1;
+           Fixed[k]= 3;
-           Dummy[k]= 1;
+           Dummy[k]= 2;
            modell[k].maintype= VTYPE;
            modell[k].subtype= VPQQ;              /*      Product fixed quantitative * varying quantitative */
-           ncovv++; /* Varying variables without age */
+           ncova++; /* Varying variables without age */
-           TvarV[ncovv]=Tvar[k];
+           TvarV[ncova]=Tvar[k];
-           TvarVind[ncovv]=k;
+           TvarVind[ncova]=k;
-           ncovv++; /* Varying variables without age */
+           /* ncova++; /\* Varying variables without age *\/ */
-           TvarV[ncovv]=Tvar[k];
+           /* TvarV[ncova]=Tvar[k]; */
-           TvarVind[ncovv]=k;
+           /* TvarVind[ncova]=k; */
          }
        }else if(Tvard[k1][1] <=ncovcol+nqv+ntv){ /* Vn is time varying dummy */
          if(Tvard[k1][2] <=ncovcol){
-           Fixed[k]= 1;
+           Fixed[k]= 2;
-           Dummy[k]= 1;
+           Dummy[k]= 2;
            modell[k].maintype= VTYPE;
            modell[k].subtype= VPDD;              /*      Product time varying dummy * fixed dummy */
-           ncovv++; /* Varying variables without age */
+           /* ncova++; /\* Varying variables with age *\/ */
-           TvarV[ncovv]=Tvar[k];
+           /* TvarV[ncova]=Tvar[k]; */
-           TvarVind[ncovv]=k;
+           /* TvarVind[ncova]=k; */
          }else if(Tvard[k1][2] <=ncovcol+nqv){
-           Fixed[k]= 1;
+           Fixed[k]= 2;
-           Dummy[k]= 1;
+           Dummy[k]= 3;
            modell[k].maintype= VTYPE;
            modell[k].subtype= VPDQ;              /*      Product time varying dummy * fixed quantitative */
-           ncovv++; /* Varying variables without age */
+           /* ncova++; /\* Varying variables with age *\/ */
-           TvarV[ncovv]=Tvar[k];
+           /* TvarV[ncova]=Tvar[k]; */
-           TvarVind[ncovv]=k;
+           /* TvarVind[ncova]=k; */
          }else if(Tvard[k1][2] <=ncovcol+nqv+ntv){
-           Fixed[k]= 1;
+           Fixed[k]= 3;
-           Dummy[k]= 0;
+           Dummy[k]= 2;
            modell[k].maintype= VTYPE;
            modell[k].subtype= VPDD;              /*      Product time varying dummy * time varying dummy */
-           ncovv++; /* Varying variables without age */
+           /* ncova++; /\* Varying variables with age *\/ */
-           TvarV[ncovv]=Tvar[k];
+           /* TvarV[ncova]=Tvar[k]; */
-           TvarVind[ncovv]=k;
+           /* TvarVind[ncova]=k; */
          }else if(Tvard[k1][2] <=ncovcol+nqv+ntv+nqtv){
-           Fixed[k]= 1;
+           Fixed[k]= 3;
-           Dummy[k]= 1;
+           Dummy[k]= 3;
            modell[k].maintype= VTYPE;
            modell[k].subtype= VPDQ;              /*      Product time varying dummy * time varying quantitative */
-           ncovv++; /* Varying variables without age */
+           /* ncova++; /\* Varying variables with age *\/ */
-           TvarV[ncovv]=Tvar[k];
+           /* TvarV[ncova]=Tvar[k]; */
-           TvarVind[ncovv]=k;
+           /* TvarVind[ncova]=k; */
          }
        }else if(Tvard[k1][1] <=ncovcol+nqv+ntv+nqtv){ /* Vn is time varying quanti */
          if(Tvard[k1][2] <=ncovcol){
-           Fixed[k]= 1;
+           Fixed[k]= 2;
-           Dummy[k]= 1;
+           Dummy[k]= 2;
            modell[k].maintype= VTYPE;
            modell[k].subtype= VPDQ;              /*      Product time varying quantitative * fixed dummy */
-           ncovv++; /* Varying variables without age */
+           /* ncova++; /\* Varying variables with age *\/ */
-           TvarV[ncovv]=Tvar[k];
+           /* TvarV[ncova]=Tvar[k]; */
-           TvarVind[ncovv]=k;
+           /* TvarVind[ncova]=k; */
          }else if(Tvard[k1][2] <=ncovcol+nqv){
-           Fixed[k]= 1;
+           Fixed[k]= 2;
-           Dummy[k]= 1;
+           Dummy[k]= 3;
            modell[k].maintype= VTYPE;
            modell[k].subtype= VPQQ;              /*      Product time varying quantitative * fixed quantitative */
-           ncovv++; /* Varying variables without age */
+           /* ncova++; /\* Varying variables with age *\/ */
-           TvarV[ncovv]=Tvar[k];
+           /* TvarV[ncova]=Tvar[k]; */
-           TvarVind[ncovv]=k;
+           /* TvarVind[ncova]=k; */
          }else if(Tvard[k1][2] <=ncovcol+nqv+ntv){
-           Fixed[k]= 1;
+           Fixed[k]= 3;
-           Dummy[k]= 1;
+           Dummy[k]= 2;
            modell[k].maintype= VTYPE;
            modell[k].subtype= VPDQ;              /*      Product time varying quantitative * time varying dummy */
-           ncovv++; /* Varying variables without age */
+           /* ncova++; /\* Varying variables with age *\/ */
-           TvarV[ncovv]=Tvar[k];
+           /* TvarV[ncova]=Tvar[k]; */
-           TvarVind[ncovv]=k;
+           /* TvarVind[ncova]=k; */
          }else if(Tvard[k1][2] <=ncovcol+nqv+ntv+nqtv){
-           Fixed[k]= 1;
+           Fixed[k]= 3;
-           Dummy[k]= 1;
+           Dummy[k]= 3;
            modell[k].maintype= VTYPE;
            modell[k].subtype= VPQQ;              /*      Product time varying quantitative * time varying quantitative */
-           ncovv++; /* Varying variables without age */
+           /* ncova++; /\* Varying variables with age *\/ */
-           TvarV[ncovv]=Tvar[k];
+           /* TvarV[ncova]=Tvar[k]; */
-           TvarVind[ncovv]=k;
+           /* TvarVind[ncova]=k; */
          }
        }else{
          printf("Error unknown type of covariate: Tvard[%d][1]=%d,Tvard[%d][2]=%d\n",k1,Tvard[k1][1],k1,Tvard[k1][2]);
          fprintf(ficlog,"Error unknown type of covariate: Tvard[%d][1]=%d,Tvard[%d][2]=%d\n",k1,Tvard[k1][1],k1,Tvard[k1][2]);
        } /*end k1*/
-     }else{
+     } else{
        printf("Error, current version can't treat for performance reasons, Tvar[%d]=%d, Typevar[%d]=%d\n", k, Tvar[k], k, Typevar[k]);
        fprintf(ficlog,"Error, current version can't treat for performance reasons, Tvar[%d]=%d, Typevar[%d]=%d\n", k, Tvar[k], k, Typevar[k]);
      }
- Line 11551  Dummy[k] 0=dummy (0 1), 1 quantitative (
+ Line 13832  Dummy[k] 0=dummy (0 1), 1 quantitative (
      /* printf("           modell[%d].maintype=%d, modell[%d].subtype=%d\n",k,modell[k].maintype,k,modell[k].subtype); */
      fprintf(ficlog,"Decodemodel, k=%d, Tvar[%d]=V%d,Typevar=%d, Fixed=%d, Dummy=%d\n",k, k,Tvar[k],Typevar[k],Fixed[k],Dummy[k]);
    }
+   ncovvta=ncovva;
    /* Searching for doublons in the model */
    for(k1=1; k1<= cptcovt;k1++){
      for(k2=1; k2 <k1;k2++){
- Line 11578  Dummy[k] 0=dummy (0 1), 1 quantitative (
+ Line 13860  Dummy[k] 0=dummy (0 1), 1 quantitative (
    fprintf(ficlog,"ncoveff=%d, nqfveff=%d, ntveff=%d, nqtveff=%d, cptcovn=%d\n",ncoveff,nqfveff,ntveff,nqtveff,cptcovn);
    printf("ncovf=%d, ncovv=%d, ncova=%d, nsd=%d, nsq=%d\n",ncovf,ncovv,ncova,nsd,nsq);
    fprintf(ficlog,"ncovf=%d, ncovv=%d, ncova=%d, nsd=%d, nsq=%d\n",ncovf,ncovv,ncova,nsd, nsq);
+   free_imatrix(existcomb,1,NCOVMAX,1,NCOVMAX);
    return (0); /* with covar[new additional covariate if product] and Tage if age */
    /*endread:*/
    printf("Exiting decodemodel: ");
- Line 12117  int hPijx(double *p, int bage, int fage)
+ Line 14401  int hPijx(double *p, int bage, int fage)
    int agelim;
    int hstepm;
    int nhstepm;
-   int h, i, i1, j, k, k4, nres=0;
+   int h, i, i1, j, k, nres=0;
    double agedeb;
    double ***p3mat;
- Line 12323  int main(int argc, char *argv[])
+ Line 14607  int main(int argc, char *argv[])
    double fret;
    double dum=0.; /* Dummy variable */
-   double ***p3mat;
+   /* double*** p3mat;*/
    /* double ***mobaverage; */
    double wald;
-   char line[MAXLINE];
+   char line[MAXLINE], linetmp[MAXLINE];
    char path[MAXLINE],pathc[MAXLINE],pathcd[MAXLINE],pathtot[MAXLINE];
    char  modeltemp[MAXLINE];
- Line 12336  int main(int argc, char *argv[])
+ Line 14620  int main(int argc, char *argv[])
    char pathr[MAXLINE], pathimach[MAXLINE];
    char *tok, *val; /* pathtot */
    /* int firstobs=1, lastobs=10; /\* nobs = lastobs-firstobs declared globally ;*\/ */
-   int c,  h , cpt, c2;
+   int c, h; /* c2; */
    int jl=0;
    int i1, j1, jk, stepsize=0;
    int count=0;
- Line 12371  int main(int argc, char *argv[])
+ Line 14655  int main(int argc, char *argv[])
    double ***delti3; /* Scale */
    double *delti; /* Scale */
    double ***eij, ***vareij;
-   double **varpl; /* Variances of prevalence limits by age */
+   //double **varpl; /* Variances of prevalence limits by age */
    double *epj, vepp;
- Line 12429  int main(int argc, char *argv[])
+ Line 14713  int main(int argc, char *argv[])
    getcwd(pathcd, size);
  #endif
    syscompilerinfo(0);
-   printf("\nIMaCh version %s, %s\n%s",version, copyright, fullversion);
+   printf("\nIMaCh prax version %s, %s\n%s",version, copyright, fullversion);
    if(argc <=1){
      printf("\nEnter the parameter file name: ");
      if(!fgets(pathr,FILENAMELENGTH,stdin)){
- Line 12660  int main(int argc, char *argv[])
+ Line 14944  int main(int argc, char *argv[])
      }else
        break;
    }
-   if((num_filled=sscanf(line,"model=1+age%[^.\n]", model)) !=EOF){
+   if((num_filled=sscanf(line,"model=%[^.\n]", model)) !=EOF){ /* Every character after model but dot and  return */
+     if (num_filled != 1){
+       printf("ERROR %d: Model should be at minimum 'model=1+age+' instead of '%s'\n",num_filled, line);
+       fprintf(ficlog,"ERROR %d: Model should be at minimum 'model=1+age+' instead of '%s'\n",num_filled, line);
+       model[0]='\0';
+       goto end;
+     }else{
+       trimbtab(linetmp,line); /* Trims multiple blanks in line */
+       strcpy(line, linetmp);
+     }
+   }
+   if((num_filled=sscanf(line,"model=1+age%[^.\n]", model)) !=EOF){ /* Every character after 1+age but dot and  return */
      if (num_filled != 1){
        printf("ERROR %d: Model should be at minimum 'model=1+age+' instead of '%s'\n",num_filled, line);
        fprintf(ficlog,"ERROR %d: Model should be at minimum 'model=1+age+' instead of '%s'\n",num_filled, line);
- Line 13001  Please run with mle=-1 to get a correct
+ Line 15296  Please run with mle=-1 to get a correct
    TvarVQind=ivector(1,NCOVMAX); /*  */
    TvarVV=ivector(1,NCOVMAX); /*  */
    TvarVVind=ivector(1,NCOVMAX); /*  */
+   TvarVVA=ivector(1,NCOVMAX); /*  */
+   TvarVVAind=ivector(1,NCOVMAX); /*  */
+   TvarAVVA=ivector(1,NCOVMAX); /*  */
+   TvarAVVAind=ivector(1,NCOVMAX); /*  */
    Tvalsel=vector(1,NCOVMAX); /*  */
    Tvarsel=ivector(1,NCOVMAX); /*  */
    Typevar=ivector(-1,NCOVMAX); /* -1 to 2 */
    Fixed=ivector(-1,NCOVMAX); /* -1 to 3 */
    Dummy=ivector(-1,NCOVMAX); /* -1 to 3 */
+   DummyV=ivector(-1,NCOVMAX); /* 1 to 3 */
+   FixedV=ivector(-1,NCOVMAX); /* 1 to 3 */
    /*  V2+V1+V4+age*V3 is a model with 4 covariates (3 plus signs).
        For each model-covariate stores the data-covariate id. Tvar[1]=2, Tvar[2]=1, Tvar[3]=4,
        Tvar[4=age*V3] is 3 and 'age' is recorded in Tage.
- Line 13026  Please run with mle=-1 to get a correct
+ Line 15328  Please run with mle=-1 to get a correct
    Tvard=imatrix(1,NCOVMAX,1,2); /* n=Tvard[k1][1]  and m=Tvard[k1][2] gives the couple n,m of the k1 th product Vn*Vm
                              * For V3*V2 (in V2+V1+V1*V4+age*V3+V3*V2), V3*V2 position is 2nd.
                              * Tvard[k1=2][1]=3 (V3) Tvard[k1=2][2]=2(V2) */
-   Tvardk=imatrix(1,NCOVMAX,1,2);
+   Tvardk=imatrix(0,NCOVMAX,1,2);
    Tage=ivector(1,NCOVMAX); /* Gives the covariate id of covariates associated with age: V2 + V1 + age*V4 + V3*age
 covariates (3 plus signs)
                           Tage[1=V3*age]= 4; Tage[2=age*V4] = 3
- Line 13046  Please run with mle=-1 to get a correct
+ Line 15348  Please run with mle=-1 to get a correct
                                  * Tmodelqind[1]=1,Tvaraff[1]@9={4,
                                  * 3, 1, 0, 0, 0, 0, 0, 0},
                                  * model=V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1*/
+ /* Probably useless zeroes */
+   for(i=1;i<NCOVMAX;i++){
+     DummyV[i]=0;
+     FixedV[i]=0;
+   }
+   for(i=1; i <=ncovcol;i++){
+     DummyV[i]=0;
+     FixedV[i]=0;
+   }
+   for(i=ncovcol+1; i <=ncovcol+nqv;i++){
+     DummyV[i]=1;
+     FixedV[i]=0;
+   }
+   for(i=ncovcol+nqv+1; i <=ncovcol+nqv+ntv;i++){
+     DummyV[i]=0;
+     FixedV[i]=1;
+   }
+   for(i=ncovcol+nqv+ntv+1; i <=ncovcol+nqv+ntv+nqtv;i++){
+     DummyV[i]=1;
+     FixedV[i]=1;
+   }
+   for(i=1; i <=ncovcol+nqv+ntv+nqtv;i++){
+     printf("Covariate type in the data: V%d, DummyV(V%d)=%d, FixedV(V%d)=%d\n",i,i,DummyV[i],i,FixedV[i]);
+     fprintf(ficlog,"Covariate type in the data: V%d, DummyV(V%d)=%d, FixedV(V%d)=%d\n",i,i,DummyV[i],i,FixedV[i]);
+   }
  /* Main decodemodel */
- Line 13283  This file: <a href=\"%s\">%s</a></br>Tit
+ Line 15615  This file: <a href=\"%s\">%s</a></br>Tit
    /* Calculates basic frequencies. Computes observed prevalence at single age
                   and for any valid combination of covariates
       and prints on file fileres'p'. */
-   freqsummary(fileres, p, pstart, agemin, agemax, s, agev, nlstate, imx, Tvaraff, invalidvarcomb, nbcode, ncodemax,mint,anint,strstart, \
+   freqsummary(fileres, p, pstart, (double)agemin, agemax, s, agev, nlstate, imx, Tvaraff, invalidvarcomb, nbcode, ncodemax,mint,anint,strstart, \
                firstpass, lastpass,  stepm,  weightopt, model);
    fprintf(fichtm,"\n");
- Line 13374  Interval (in months) between two waves:
+ Line 15706  Interval (in months) between two waves:
  #ifdef GSL
      printf("GSL optimization\n");  fprintf(ficlog,"Powell\n");
  #else
-     printf("Powell\n");  fprintf(ficlog,"Powell\n");
+     printf("Powell-mort\n");  fprintf(ficlog,"Powell-mort\n");
  #endif
      strcpy(filerespow,"POW-MORT_");
      strcat(filerespow,fileresu);
- Line 13477  Interval (in months) between two waves:
+ Line 15809  Interval (in months) between two waves:
      for(i=1; i <=NDIM; i++)
        for(j=i+1;j<=NDIM;j++)
-                                 matcov[i][j]=matcov[j][i];
+         matcov[i][j]=matcov[j][i];
      printf("\nCovariance matrix\n ");
      fprintf(ficlog,"\nCovariance matrix\n ");
- Line 13622  Please run with mle=-1 to get a correct
+ Line 15954  Please run with mle=-1 to get a correct
          fprintf(ficres,"  +    V%d*V%d ",Tvard[Tposprod[j]][1],Tvard[Tposprod[j]][2]);
          fprintf(ficlog,"  +    V%d*V%d ",Tvard[Tposprod[j]][1],Tvard[Tposprod[j]][2]);
          fprintf(fichtm, "<th>+  V%d*V%d</th>",Tvard[Tposprod[j]][1],Tvard[Tposprod[j]][2]);
+       }else if(Typevar[j]==3) { /* TO VERIFY */
+         printf("  +    V%d*V%d*age ",Tvard[Tposprod[j]][1],Tvard[Tposprod[j]][2]);
+         fprintf(ficres,"  +    V%d*V%d*age ",Tvard[Tposprod[j]][1],Tvard[Tposprod[j]][2]);
+         fprintf(ficlog,"  +    V%d*V%d*age ",Tvard[Tposprod[j]][1],Tvard[Tposprod[j]][2]);
+         fprintf(fichtm, "<th>+  V%d*V%d*age</th>",Tvard[Tposprod[j]][1],Tvard[Tposprod[j]][2]);
        }
      }
      printf("\n");
- Line 13681  Please run with mle=-1 to get a correct
+ Line 16018  Please run with mle=-1 to get a correct
            fprintf(fichtm, "<th>+  V%d*age</th>",Tvar[j]);
          }else if(Typevar[j]==2) {
            fprintf(fichtm, "<th>+  V%d*V%d</th>",Tvard[Tposprod[j]][1],Tvard[Tposprod[j]][2]);
+         }else if(Typevar[j]==3) { /* TO VERIFY */
+           fprintf(fichtm, "<th>+  V%d*V%d*age</th>",Tvard[Tposprod[j]][1],Tvard[Tposprod[j]][2]);
          }
        }
        fprintf(fichtm, "</tr>\n");
- Line 13738  Please run with mle=-1 to get a correct
+ Line 16077  Please run with mle=-1 to get a correct
      }
      fprintf(ficres,"# Covariance matrix \n# 121 Var(a12)\n# 122 Cov(b12,a12) Var(b12)\n#   ...\n# 232 Cov(b23,a12)  Cov(b23,b12) ... Var (b23)\n");
-     if(mle >= 1) /* To big for the screen */
+     if(mle >= 1) /* Too big for the screen */
        printf("# Covariance matrix \n# 121 Var(a12)\n# 122 Cov(b12,a12) Var(b12)\n#   ...\n# 232 Cov(b23,a12)  Cov(b23,b12) ... Var (b23)\n");
      fprintf(ficlog,"# Covariance matrix \n# 121 Var(a12)\n# 122 Cov(b12,a12) Var(b12)\n#   ...\n# 232 Cov(b23,a12)  Cov(b23,b12) ... Var (b23)\n");
      /* # 121 Var(a12)\n\ */
- Line 13924  Please run with mle=-1 to get a correct
+ Line 16263  Please run with mle=-1 to get a correct
      }
      /* Results */
-     /* Value of covariate in each resultine will be compututed (if product) and sorted according to model rank */
+     /* Value of covariate in each resultine will be computed (if product) and sorted according to model rank */
      /* It is precov[] because we need the varying age in order to compute the real cov[] of the model equation */
      precov=matrix(1,MAXRESULTLINESPONE,1,NCOVMAX+1);
      endishere=0;
- Line 14094  Please run with mle=-1 to get a correct
+ Line 16433  Please run with mle=-1 to get a correct
          date2dmy(datebackf,&jbackf, &mbackf, &anbackf);
        }
-       printinggnuplot(fileresu, optionfilefiname,ageminpar,agemaxpar,bage, fage, prevfcast, prevbcast, pathc,p, (int)anprojd-bage, (int)anbackd-fage);
+       printinggnuplot(fileresu, optionfilefiname,ageminpar,agemaxpar,bage, fage, prevfcast, prevbcast, pathc,p, (int)anprojd-bage, (int)anbackd-fage);/* HERE valgrind Tvard*/
      }
      printinghtml(fileresu,title,datafile, firstpass, lastpass, stepm, weightopt, \
                   model,imx,jmin,jmax,jmean,rfileres,popforecast,mobilav,prevfcast,mobilavproj,prevbcast, estepm, \
- Line 14244  Please run with mle=-1 to get a correct
+ Line 16583  Please run with mle=-1 to get a correct
      pstamp(ficreseij);
-     i1=pow(2,cptcoveff); /* Number of combination of dummy covariates */
+     /* i1=pow(2,cptcoveff); /\* Number of combination of dummy covariates *\/ */
-     if (cptcovn < 1){i1=1;}
+     /* if (cptcovn < 1){i1=1;} */
-     for(nres=1; nres <= nresult; nres++) /* For each resultline */
+     for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-     for(k=1; k<=i1;k++){ /* For any combination of dummy covariates, fixed and varying */
+     /* for(k=1; k<=i1;k++){ /\* For any combination of dummy covariates, fixed and varying *\/ */
-       if(i1 != 1 && TKresult[nres]!= k)
+       /* if(i1 != 1 && TKresult[nres]!= k) */
-         continue;
+       /*        continue; */
        fprintf(ficreseij,"\n#****** ");
        printf("\n#****** ");
-       for(j=1;j<=cptcoveff;j++) {
+       for(j=1;j<=cptcovs;j++){
-         fprintf(ficreseij,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]);
+       /* for(j=1;j<=cptcoveff;j++) { */
-         printf("V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]);
+         /* fprintf(ficreseij,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
+         fprintf(ficreseij," V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
+         printf(" V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
+         /* printf("V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
        }
        for (j=1; j<= nsq; j++){ /* For each selected (single) quantitative value */
          printf(" V%d=%lg ",TvarsQ[j], TinvDoQresult[nres][TvarsQ[j]]); /* TvarsQ[j] gives the name of the jth quantitative (fixed or time v) */
- Line 14324  Please run with mle=-1 to get a correct
+ Line 16666  Please run with mle=-1 to get a correct
        /* */
        if(i1 != 1 && TKresult[nres]!= k) /* TKresult[nres] is the combination of this nres resultline. All the i1 combinations are not output */
          continue;
-       printf("\n# model %s \n#****** Result for:", model);
+       printf("\n# model=1+age+%s \n#****** Result for:", model);  /* HERE model is empty */
-       fprintf(ficrest,"\n# model %s \n#****** Result for:", model);
+       fprintf(ficrest,"\n# model=1+age+%s \n#****** Result for:", model);
-       fprintf(ficlog,"\n# model %s \n#****** Result for:", model);
+       fprintf(ficlog,"\n# model=1+age+%s \n#****** Result for:", model);
        /* It might not be a good idea to mix dummies and quantitative */
        /* for(j=1;j<=cptcoveff;j++){ /\* j=resultpos. Could be a loop on cptcovs: number of single dummy covariate in the result line as well as in the model *\/ */
        for(j=1;j<=cptcovs;j++){ /* j=resultpos. Could be a loop on cptcovs: number of single covariate (dummy or quantitative) in the result line as well as in the model */
- Line 14352  Please run with mle=-1 to get a correct
+ Line 16694  Please run with mle=-1 to get a correct
          /*   printf("\n j=%d In computing T_ Dummy[modelresult[%d][%d]]=%d, modelresult[%d][%d]=%d cptcovs=%d, cptcoveff=%d Fixed[modelresult[nres][j]]=%d\n", j, nres, j, Dummy[modelresult[nres][j]],nres,j,modelresult[nres][j],cptcovs, cptcoveff,Fixed[modelresult[nres][j]]);  /\* end if dummy  or quanti *\/ */
          if(Dummy[modelresult[nres][j]]==0){/* Dummy variable of the variable in position modelresult in the model corresponding to j in resultline  */
-           printf("V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][j]); /* Output of each value for the combination TKresult[nres], ordere by the covariate values in the resultline  */
+           /* printf("V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][j]); /\* Output of each value for the combination TKresult[nres], ordere by the covariate values in the resultline  *\/ */ /* TinvDoQresult[nres][Name of the variable] */
-           fprintf(ficlog,"V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][j]); /* Output of each value for the combination TKresult[nres], ordere by the covariate values in the resultline  */
+           printf("V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]); /* Output of each value for the combination TKresult[nres], ordered by the covariate values in the resultline  */
-           fprintf(ficrest,"V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][j]); /* Output of each value for the combination TKresult[nres], ordere by the covariate values in the resultline  */
+           fprintf(ficlog,"V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]); /* Output of each value for the combination TKresult[nres], ordere by the covariate values in the resultline  */
+           fprintf(ficrest,"V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]); /* Output of each value for the combination TKresult[nres], ordere by the covariate values in the resultline  */
            if(Fixed[modelresult[nres][j]]==0){ /* Fixed */
              printf("fixed ");fprintf(ficlog,"fixed ");fprintf(ficrest,"fixed ");
            }else{
- Line 14433  Please run with mle=-1 to get a correct
+ Line 16776  Please run with mle=-1 to get a correct
        for(vpopbased=0; vpopbased <= popbased; vpopbased++){ /* Done for vpopbased=0 and vpopbased=1 if popbased==1*/
          oldm=oldms;savm=savms; /* ZZ Segmentation fault */
          cptcod= 0; /* To be deleted */
-         printf("varevsij vpopbased=%d \n",vpopbased);
+         printf("varevsij vpopbased=%d popbased=%d \n",vpopbased,popbased);
-         fprintf(ficlog, "varevsij vpopbased=%d \n",vpopbased);
+         fprintf(ficlog, "varevsij vpopbased=%d popbased=%d \n",vpopbased,popbased);
          varevsij(optionfilefiname, vareij, matcov, p, delti, nlstate, stepm, (int) bage, (int) fage, oldm, savm, prlim, ftolpl, &ncvyear, k, estepm, cptcov,cptcod,vpopbased,mobilav, strstart, nres); /* cptcod not initialized Intel */
-         fprintf(ficrest,"# Total life expectancy with std error and decomposition into time to be expected in each health state\n#  (weighted average of eij where weights are ");
+         fprintf(ficrest,"# Total life expectancy with std error and decomposition into time to be expected in each state\n\
+ #  (these are weighted average of eij where weights are ");
          if(vpopbased==1)
-           fprintf(ficrest,"the age specific prevalence observed (cross-sectionally) in the population i.e cross-sectionally\n in each health state (popbased=1) (mobilav=%d)\n",mobilav);
+           fprintf(ficrest,"the age specific prevalence observed (cross-sectionally) in the population i.e cross-sectionally)\n in each health state (popbased=1) (mobilav=%d)\n",mobilav);
          else
-           fprintf(ficrest,"the age specific forward period (stable) prevalences in each health state \n");
+           fprintf(ficrest,"the age specific forward period (stable) prevalences in each state) \n");
+         fprintf(ficrest,"# with proportions of time spent in each state with standard error (on the right of the table.\n ");
          fprintf(ficrest,"# Age popbased mobilav e.. (std) "); /* Adding covariate values? */
          for (i=1;i<=nlstate;i++) fprintf(ficrest,"e.%d (std) ",i);
+         for (i=1;i<=nlstate;i++) fprintf(ficrest," %% e.%d/e.. (std) ",i);
          fprintf(ficrest,"\n");
          /* printf("Which p?\n"); for(i=1;i<=npar;i++)printf("p[i=%d]=%lf,",i,p[i]);printf("\n"); */
          printf("Computing age specific forward period (stable) prevalences in each health state \n");
- Line 14476  Please run with mle=-1 to get a correct
+ Line 16822  Please run with mle=-1 to get a correct
              for(j=1;j <=nlstate;j++)
                vepp += vareij[i][j][(int)age];
            fprintf(ficrest," %7.3f (%7.3f)", epj[nlstate+1],sqrt(vepp));
+           /* vareij[j][i] is the variance of epj */
            for(j=1;j <=nlstate;j++){
              fprintf(ficrest," %7.3f (%7.3f)", epj[j],sqrt(vareij[j][j][(int)age]));
            }
+           /* And proportion of time spent in state j */
+           /* $$ E[r(X,Y)-E(r(X,Y))]^2=[\frac{1}{\mu_y} -\frac{\mu_x}{{\mu_y}^2}]' Var(X,Y)[\frac{1}{\mu_y} -\frac{\mu_x}{{\mu_y}^2}]$$ */
+           /* \sigma^2_x/\mu_y^2 +\sigma^2_y \mu^2x/\mu_y^4 */
+           /*\mu_x = epj[j], \sigma^2_x = vareij[j][j][(int)age] and \mu_y=epj[nlstate+1], \sigma^2_y=vepp */
+           /* vareij[j][j][(int)age]/epj[nlstate+1]^2 + vepp/epj[nlstata+1]^4 */
+           for(j=1;j <=nlstate;j++){
+             /* fprintf(ficrest," %7.3f (%7.3f)", epj[j]/epj[nlstate+1], sqrt( vareij[j][j][(int)age]/epj[j]/epj[j] + vepp/epj[j]/epj[j]/epj[j]/epj[j] )); */
+             fprintf(ficrest," %7.3f (%7.3f)", epj[j]/epj[nlstate+1], sqrt( vareij[j][j][(int)age]/epj[nlstate+1]/epj[nlstate+1] + vepp/epj[nlstate+1]/epj[nlstate+1]/epj[nlstate+1]/epj[nlstate+1] ));
+           }
            fprintf(ficrest,"\n");
          }
        } /* End vpopbased */
- Line 14498  Please run with mle=-1 to get a correct
+ Line 16854  Please run with mle=-1 to get a correct
      free_vector(weight,firstobs,lastobs);
-     free_imatrix(Tvardk,1,NCOVMAX,1,2);
+     free_imatrix(Tvardk,0,NCOVMAX,1,2);
      free_imatrix(Tvard,1,NCOVMAX,1,2);
      free_imatrix(s,1,maxwav+1,firstobs,lastobs);
      free_matrix(anint,1,maxwav,firstobs,lastobs);
- Line 14520  Please run with mle=-1 to get a correct
+ Line 16876  Please run with mle=-1 to get a correct
      free_matrix(pmmij,1,nlstate+ndeath,1,nlstate+ndeath);
    }  /* mle==-3 arrives here for freeing */
    /* endfree:*/
+   if(mle!=-3) free_matrix(precov, 1,MAXRESULTLINESPONE,1,NCOVMAX+1); /* Could be elsewhere ?*/
    free_matrix(oldms, 1,nlstate+ndeath,1,nlstate+ndeath);
    free_matrix(newms, 1,nlstate+ndeath,1,nlstate+ndeath);
    free_matrix(savms, 1,nlstate+ndeath,1,nlstate+ndeath);
- Line 14540  Please run with mle=-1 to get a correct
+ Line 16897  Please run with mle=-1 to get a correct
    free_ivector(ncodemaxwundef,1,NCOVMAX);
    free_ivector(Dummy,-1,NCOVMAX);
    free_ivector(Fixed,-1,NCOVMAX);
-   free_ivector(DummyV,1,NCOVMAX);
+   free_ivector(DummyV,-1,NCOVMAX);
-   free_ivector(FixedV,1,NCOVMAX);
+   free_ivector(FixedV,-1,NCOVMAX);
    free_ivector(Typevar,-1,NCOVMAX);
    free_ivector(Tvar,1,NCOVMAX);
    free_ivector(TvarsQ,1,NCOVMAX);
- Line 14563  Please run with mle=-1 to get a correct
+ Line 16920  Please run with mle=-1 to get a correct
    free_ivector(TvarVDind,1,NCOVMAX);
    free_ivector(TvarVQ,1,NCOVMAX);
    free_ivector(TvarVQind,1,NCOVMAX);
+   free_ivector(TvarAVVA,1,NCOVMAX);
+   free_ivector(TvarAVVAind,1,NCOVMAX);
+   free_ivector(TvarVVA,1,NCOVMAX);
+   free_ivector(TvarVVAind,1,NCOVMAX);
    free_ivector(TvarVV,1,NCOVMAX);
    free_ivector(TvarVVind,1,NCOVMAX);
- Line 14577  Please run with mle=-1 to get a correct
+ Line 16938  Please run with mle=-1 to get a correct
    free_ivector(TmodelInvind,1,NCOVMAX);
    free_ivector(TmodelInvQind,1,NCOVMAX);
-   free_matrix(precov, 1,MAXRESULTLINESPONE,1,NCOVMAX+1); /* Could be elsewhere ?*/
+   /* free_matrix(precov, 1,MAXRESULTLINESPONE,1,NCOVMAX+1); /\* Could be elsewhere ?*\/ */
    free_imatrix(nbcode,0,NCOVMAX,0,NCOVMAX);
    /* free_imatrix(codtab,1,100,1,10); */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.343
changed lines
	Added in v.1.360