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.328 and 1.362

-version 1.328, 2022/07/27 17:40:48
+version 1.362, 2024/06/28 08:00:31
  Line 1
  /* $Id$
    $State$
    $Log$
+   Revision 1.362  2024/06/28 08:00:31  brouard
+   Summary: 0.99s6
+   * imach.c (Module): s6 errors with age*age (harmless).
+   Revision 1.361  2024/05/12 20:29:32  brouard
+   Summary: Version 0.99s5
+   * src/imach.c Version 0.99s5 In fact, the covariance of total life
+   expectancy e.. with a partial life expectancy e.j is high,
+   therefore the complete matrix of variance covariance has to be
+   included in the formula of the standard error of the proportion of
+   total life expectancy spent in a specific state:
+   var(X/Y)=mu_x^2/mu_y^2*(sigma_x^2/mu_x^2 -2
+   sigma_xy/mu_x/mu_y+sigma^2/mu_y^2).  Also an error with mle=-3
+   made the program core dump. It is fixed in this version.
+   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
+   * imach.c (Module): Version 0.99r39 with colored dummy covariates
+   (fixed or time varying), using new last columns of
+   ILK_parameter.txt file.
+   Revision 1.342  2022/09/11 19:54:09  brouard
+   Summary: 0.99r38
+   * imach.c (Module): Adding timevarying products of any kinds,
+   should work before shifting cotvar from ncovcol+nqv columns in
+   order to have a correspondance between the column of cotvar and
+   the id of column.
+   (Module): Some cleaning and adding covariates in ILK.txt
+   Revision 1.341  2022/09/11 07:58:42  brouard
+   Summary: Version 0.99r38
+   After adding change in cotvar.
+   Revision 1.340  2022/09/11 07:53:11  brouard
+   Summary: Version imach 0.99r37
+   * imach.c (Module): Adding timevarying products of any kinds,
+   should work before shifting cotvar from ncovcol+nqv columns in
+   order to have a correspondance between the column of cotvar and
+   the id of column.
+   Revision 1.339  2022/09/09 17:55:22  brouard
+   Summary: version 0.99r37
+   * imach.c (Module): Many improvements for fixing products of fixed
+   timevarying as well as fixed * fixed, and test with quantitative
+   covariate.
+   Revision 1.338  2022/09/04 17:40:33  brouard
+   Summary: 0.99r36
+   * imach.c (Module): Now the easy runs i.e. without result or
+   model=1+age only did not work. The defautl combination should be 1
+   and not 0 because everything hasn't been tranformed yet.
+   Revision 1.337  2022/09/02 14:26:02  brouard
+   Summary: version 0.99r35
+   * src/imach.c: Version 0.99r35 because it outputs same results with
++age+V1+V1*age for females and 1+age for females only
+   (education=1 noweight)
+   Revision 1.336  2022/08/31 09:52:36  brouard
+   *** empty log message ***
+   Revision 1.335  2022/08/31 08:23:16  brouard
+   Summary: improvements...
+   Revision 1.334  2022/08/25 09:08:41  brouard
+   Summary: In progress for quantitative
+   Revision 1.333  2022/08/21 09:10:30  brouard
+   * src/imach.c (Module): Version 0.99r33 A lot of changes in
+   reassigning covariates: my first idea was that people will always
+   use the first covariate V1 into the model but in fact they are
+   producing data with many covariates and can use an equation model
+   with some of the covariate; it means that in a model V2+V3 instead
+   of codtabm(k,Tvaraff[j]) which calculates for combination k, for
+   three covariates (V1, V2, V3) the value of Tvaraff[j], but in fact
+   the equation model is restricted to two variables only (V2, V3)
+   and the combination for V2 should be codtabm(k,1) instead of
+   (codtabm(k,2), and the code should be
+   codtabm(k,TnsdVar[Tvaraff[j]]. Many many changes have been
+   made. All of these should be simplified once a day like we did in
+   hpxij() for example by using precov[nres] which is computed in
+   decoderesult for each nres of each resultline. Loop should be done
+   on the equation model globally by distinguishing only product with
+   age (which are changing with age) and no more on type of
+   covariates, single dummies, single covariates.
+   Revision 1.332  2022/08/21 09:06:25  brouard
+   Summary: Version 0.99r33
+   * src/imach.c (Module): Version 0.99r33 A lot of changes in
+   reassigning covariates: my first idea was that people will always
+   use the first covariate V1 into the model but in fact they are
+   producing data with many covariates and can use an equation model
+   with some of the covariate; it means that in a model V2+V3 instead
+   of codtabm(k,Tvaraff[j]) which calculates for combination k, for
+   three covariates (V1, V2, V3) the value of Tvaraff[j], but in fact
+   the equation model is restricted to two variables only (V2, V3)
+   and the combination for V2 should be codtabm(k,1) instead of
+   (codtabm(k,2), and the code should be
+   codtabm(k,TnsdVar[Tvaraff[j]]. Many many changes have been
+   made. All of these should be simplified once a day like we did in
+   hpxij() for example by using precov[nres] which is computed in
+   decoderesult for each nres of each resultline. Loop should be done
+   on the equation model globally by distinguishing only product with
+   age (which are changing with age) and no more on type of
+   covariates, single dummies, single covariates.
+   Revision 1.331  2022/08/07 05:40:09  brouard
+   *** empty log message ***
+   Revision 1.330  2022/08/06 07:18:25  brouard
+   Summary: last 0.99r31
+   *  imach.c (Module): Version of imach using partly decoderesult to rebuild xpxij function
+   Revision 1.329  2022/08/03 17:29:54  brouard
+   *  imach.c (Module): Many errors in graphs fixed with Vn*age covariates.
    Revision 1.328  2022/07/27 17:40:48  brouard
    Summary: valgrind bug fixed by initializing to zero DummyV as well as Tage
- Line 1137  Important routines
+ Line 1316  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 1188  typedef struct {
+ Line 1369  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
+ double gnuplotversion=GNUPLOTVERSION;
  /*#define GNUPLOTPROGRAM "..\\gp37mgw\\wgnuplot"*/
- #define FILENAMELENGTH 132
+ #define FILENAMELENGTH 256
  #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 1231  typedef struct {
+ Line 1414  typedef struct {
  /* $State$ */
  #include "version.h"
  char version[]=__IMACH_VERSION__;
- char copyright[]="July 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];
  int erreur=0, nberr=0, nbwarn=0; /* Error number, number of errors number of warnings  */
+ int debugILK=0; /* debugILK is set by a #d in a comment line */
  int nagesqr=0, nforce=0; /* nagesqr=1 if model is including age*age, number of forces */
- /* Number of covariates model=V2+V1+ V3*age+V2*V4 */
+ /* Number of covariates model (1)=V2+V1+ V3*age+V2*V4 */
- int cptcovn=0; /**< cptcovn number of covariates added in the model (excepting constant and age and age*product) */
+ /* Model(2)  V1 + V2 + V3 + V8 + V7*V8 + V5*V6 + V8*age + V3*age + age*age */
- int cptcovt=0; /**< cptcovt number of covariates added in the model (excepting constant and age) */
+ int cptcovn=0; /**< cptcovn decodemodel: number of covariates k of the models excluding age*products =6 and age*age but including products */
- int cptcovs=0; /**< cptcovs number of simple covariates in the model V2+V1 =2 */
+ int cptcovt=0; /**< cptcovt: total number of covariates of the model (2) nbocc(+)+1 = 8 excepting constant and age and age*age */
- int cptcovsnq=0; /**< cptcovsnq number of simple covariates in the model but non quantitative V2+V1 =2 */
+ 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 covariates to vary for printing results */
+ 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 ncova=0; /* Total number of effective (wave and stepm) varying with age covariates (dummy of 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 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 1255  int nqfveff=0; /**< nqfveff Number of Qu
+ Line 1447  int nqfveff=0; /**< nqfveff Number of Qu
  int ntveff=0; /**< ntveff number of effective time varying variables */
  int nqtveff=0; /**< ntqveff number of effective time varying quantitative variables */
  int cptcov=0; /* Working variable */
+ int firstobs=1, lastobs=10; /* nobs = lastobs-firstobs+1 declared globally ;*/
  int nobs=10;  /* Number of observations in the data lastobs-firstobs */
  int ncovcombmax=NCOVMAX; /* Maximum calculated number of covariate combination = pow(2, cptcoveff) */
  int npar=NPARMAX; /* Number of parameters (nlstate+ndeath-1)*nlstate*ncovmodel; */
  int nlstate=2; /* Number of live states */
  int ndeath=1; /* Number of dead states */
  int ncovmodel=0, ncovcol=0;     /* Total number of covariables including constant a12*1 +b12*x ncovmodel=2 */
- int  nqv=0, ntv=0, nqtv=0;    /* Total number of quantitative variables, time variable (dummy), quantitative and time variable */
+ int nqv=0, ntv=0, nqtv=0;    /* Total number of quantitative variables, time variable (dummy), quantitative and time variable*/
+ int ncovcolt=0; /* ncovcolt=ncovcol+nqv+ntv+nqtv; total of covariates in the data, not in the model equation*/
  int popbased=0;
  int *wav; /* Number of waves for this individuual 0 is possible */
  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 1332  extern time_t time();
+ Line 1527  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 1340  char *endptr;
+ Line 1536  char *endptr;
  long lval;
  double dval;
+ /* This for praxis gegen */
+   /* int prin=1; */
+   double h0=0.25;
+   double macheps;
+   double ffmin;
  #define NR_END 1
  #define FREE_ARG char*
  #define FTOL 1.0e-10
- Line 1394  int *ncodemaxwundef;  /* ncodemax[j]= Nu
+ Line 1596  int *ncodemaxwundef;  /* ncodemax[j]= Nu
  double **agev,*moisnais, *annais, *moisdc, *andc,**mint, **anint;
  double **pmmij, ***probs; /* Global pointer */
  double ***mobaverage, ***mobaverages; /* New global variable */
+ double **precov; /* New global variable to store for each resultline, values of model covariates given by the resultlines (in order to speed up)  */
  double *ageexmed,*agecens;
  double dateintmean=0;
    double anprojd, mprojd, jprojd; /* For eventual projections */
- Line 1409  double  **covar; /**< covar[j,i], value
+ Line 1612  double  **covar; /**< covar[j,i], value
                    * covar=matrix(0,NCOVMAX,1,n);
                    * cov[Tage[kk]+2]=covar[Tvar[Tage[kk]]][i]*age; */
  double **coqvar; /* Fixed quantitative covariate nqv */
- double ***cotvar; /* Time varying covariate ntv */
+ double ***cotvar; /* Time varying covariate start at ncovcol + nqv + (1 to ntv) */
  double ***cotqvar; /* Time varying quantitative covariate itqv */
  double  idx;
  int **nbcode, *Tvar; /**< model=V2 => Tvar[1]= 2 */
- Line 1418  int **nbcode, *Tvar; /**< model=V2 => Tv
+ Line 1621  int **nbcode, *Tvar; /**< model=V2 => Tv
         *  V1   V2   V3   V4  V5  V6  V7  V8  Weight ddb ddth d1st s1 V9 V10 V11 V12 s2 V9 V10 V11 V12
         *  <          ncovcol=6   >   nqv=2 (V7 V8)                   dv dv  dv  qtv    dv dv  dvv qtv
         *                                                             ntv=3     nqtv=1
-        *  cptcovn number of covariates (not including constant and age) = # of + plus 1 = 10+1=11
+        *  cptcovn number of covariates (not including constant and age or age*age) = number of plus sign + 1 = 10+1=11
         * For time varying covariate, quanti or dummies
         *       cotqvar[wav][iv(1 to nqtv)][i]= [1][12][i]=(V12) quanti
-        *       cotvar[wav][ntv+iv][i]= [3+(1 to nqtv)][i]=(V12) quanti
+        *       cotvar[wav][ncovcol+nqv+ iv(1 to nqtv)][i]= [(1 to nqtv)][i]=(V12) quanti
         *       cotvar[wav][iv(1 to ntv)][i]= [1][1][i]=(V9) dummies at wav 1
         *       cotvar[wav][iv(1 to ntv)][i]= [1][2][i]=(V10) dummies at wav 1
-        *       covar[k,i], value of kth fixed covariate dummy or quanti :
+        *       covar[Vk,i], value of the Vkth fixed covariate dummy or quanti for individual i:
         *       covar[1][i]= (V1), covar[4][i]=(V4), covar[8][i]=(V8)
         * Model V2 + V1 + V3*age + V3 + V5*V6 + V7*V8 + V8*age + V8 + V9 + V9*age + V10
         *   k=  1    2      3       4     5       6      7        8   9     10       11
- Line 1434  int **nbcode, *Tvar; /**< model=V2 => Tv
+ Line 1637  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 */
- /*    k        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 */
- /*TvarsD[nsd]     4   3                              1 */ /* ID of single dummy cova fixed or timevary*/
+ /*TnsdVar[Tvar]   1   2                               3 */
- /*TvarsDind[k]    2   3                              9 */ /* position K of single dummy cova */
+ /*Tvaraff[nsd]    4   3                               1 */ /* ID of single dummy cova fixed or timevary*/
- /*    nsq      1                     2                 */ /* Counting single quantit tv */
+ /*TvarsD[nsd]     4   3                               1 */ /* ID of single dummy cova fixed or timevary*/
- /* TvarsQ[k]   5                     2                 */ /* Number of single quantitative cova */
+ /*TvarsDind[nsd]  2   3                               9 */ /* position K of single dummy cova */
- /* TvarsQind   1                     6                 */ /* position K of single quantitative cova */
+ /*    nsq      1                     2                  */ /* Counting single quantit tv */
- /* Tprod[i]=k             1               2            */ /* Position in model of the ith prod without age */
+ /* TvarsQ[k]   5                     2                  */ /* Number of single quantitative cova */
- /* cptcovage                    1               2      */ /* Counting cov*age in the model equation */
+ /* TvarsQind   1                     6                  */ /* position K of single quantitative cova */
- /* Tage[cptcovage]=k            5               8      */ /* Position in the model of ith cov*age */
+ /* Tprod[i]=k             1               2             */ /* Position in model of the ith prod without age */
- /* Tvard[1][1]@4={4,3,1,2}    V4*V3 V1*V2              */ /* Position in model of the ith prod without age */
+ /* cptcovage                    1               2         3 */ /* Counting cov*age in the model equation */
+ /* Tage[cptcovage]=k            5               8         10 */ /* Position in the model of ith cov*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)  */
  /* Type                    */
- Line 1461  int **nbcode, *Tvar; /**< model=V2 => Tv
+ Line 1672  int **nbcode, *Tvar; /**< model=V2 => Tv
  /*           D  Q  D  D  Q */
  /*                         */
  int *TvarsD;
+ int *TnsdVar;
  int *TvarsDind;
  int *TvarsQ;
  int *TvarsQind;
- Line 1468  int *TvarsQind;
+ Line 1680  int *TvarsQind;
  #define MAXRESULTLINESPONE 10+1
  int nresult=0;
  int parameterline=0; /* # of the parameter (type) line */
- int TKresult[MAXRESULTLINESPONE];
+ int TKresult[MAXRESULTLINESPONE]; /* TKresult[nres]=k for each resultline nres give the corresponding combination of dummies */
- int Tresult[MAXRESULTLINESPONE][NCOVMAX];/* For dummy variable , value (output) */
+ int resultmodel[MAXRESULTLINESPONE][NCOVMAX];/* resultmodel[k1]=k3: k1th position in the model corresponds to the k3 position in the resultline */
- int Tinvresult[MAXRESULTLINESPONE][NCOVMAX];/* For dummy variable , value (output) */
+ int modelresult[MAXRESULTLINESPONE][NCOVMAX];/* modelresult[k3]=k1: k1th position in the model corresponds to the k3 position in the resultline */
- int Tvresult[MAXRESULTLINESPONE][NCOVMAX]; /* For dummy variable , variable # (output) */
+ int Tresult[MAXRESULTLINESPONE][NCOVMAX];/* Tresult[nres][result_position]= value of the dummy variable at the result_position in the nres resultline */
- double Tqresult[MAXRESULTLINESPONE][NCOVMAX]; /* For quantitative variable , value (output) */
+ int Tinvresult[MAXRESULTLINESPONE][NCOVMAX];/* Tinvresult[nres][Name of a dummy variable]= value of the variable in the result line  */
+ double TinvDoQresult[MAXRESULTLINESPONE][NCOVMAX];/* TinvDoQresult[nres][Name of a Dummy or Q variable]= value of the variable in the result line */
+ int Tvresult[MAXRESULTLINESPONE][NCOVMAX]; /* Tvresult[nres][result_position]= name of the dummy variable at the result_position in the nres resultline */
+ double Tqresult[MAXRESULTLINESPONE][NCOVMAX]; /* Tqresult[nres][result_position]= value of the variable at the result_position in the nres resultline */
  double Tqinvresult[MAXRESULTLINESPONE][NCOVMAX]; /* For quantitative variable , value (output) */
- int Tvqresult[MAXRESULTLINESPONE][NCOVMAX]; /* For quantitative variable , variable # (output) */
+ int Tvqresult[MAXRESULTLINESPONE][NCOVMAX]; /* Tvqresult[nres][result_position]= id of the variable at the result_position in the nres resultline */
  /* ncovcol=1(Males=0 Females=1) nqv=1(raedyrs) ntv=2(withoutiadl=0 withiadl=1, witoutadl=0 withoutadl=1) nqtv=1(bmi) nlstate=3 ndeath=1
    # States 1=Coresidence, 2 Living alone, 3 Institution
- Line 1495  int *TvarVD; /* TvarVD[1]=V5 in V5+V4+V3
+ Line 1710  int *TvarVD; /* TvarVD[1]=V5 in V5+V4+V3
  int *TvarVDind; /* TvarVDind[1]=1 in V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */ /* Only simple fixed quantitative variable */
  int *TvarVQ; /* TvarVQ[1]=V5 in V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */ /* Only simple time varying quantitative variable */
  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 + 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 */
+       /* TvarVV={3,1,3,1,3}, 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 1511  int *TmodelInvQind; /** Tmodelqind[1]=1
+ Line 1736  int *TmodelInvQind; /** Tmodelqind[1]=1
  int *Ndum; /** Freq of modality (tricode */
  /* int **codtab;*/ /**< codtab=imatrix(1,100,1,10); */
  int **Tvard;
+ int **Tvardk;
  int *Tprod;/**< Gives the k position of the k1 product */
  /* Tprod[k1=1]=3(=V1*V4) for V2+V1+V1*V4+age*V3  */
  int *Tposprod; /**< Gives the k1 product from the k position */
- Line 1634  char *trimbb(char *out, char *in)
+ Line 1860  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 1660  char *trimbb(char *out, char *in)
+ Line 1900  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 1680  char *substrchaine(char *out, char *in,
+ Line 1920  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 1746  int nbocc(char *s, char occ)
+ Line 1986  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 2394  void linmin(double p[], double xi[], int
+ Line 2656  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 might be very wrong 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 it seems that fx doesn't correspond to f(s=*x1) */
+ #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 2425  void powell(double p[], double **xi, int
+ Line 4193  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);
    xits=vector(1,n);
    *fret=(*func)(p);
    for (j=1;j<=n;j++) pt[j]=p[j];
    rcurr_time = time(NULL);
+   fp=(*fret); /* Initialisation */
    for (*iter=1;;++(*iter)) {
      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);
+     /* 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);
+     /* 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); */
- /*     fprintf(ficrespow,"%d %.12f %ld",*iter,*fret,curr_time.tm_sec-start_time.tm_sec); */
+     /* Bigter=(*iter - *iter % ncovmodel)/ncovmodel +1; /\* Big iteration, i.e on ncovmodel cycle *\/ */
+     Bigter=(*iter - (*iter-1) % n)/n +1; /* Big iteration, i.e on ncovmodel cycle */
+     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 2454  void powell(double p[], double **xi, int
+ Line 4229  void powell(double p[], double **xi, int
          printf("  + age*age  ");
          fprintf(ficlog,"  + age*age  ");
      }
-     for(j=1;j <=ncovmodel-2;j++){
+     for(j=1;j <=ncovmodel-2-nagesqr;j++){
        if(Typevar[j]==0) {
          printf("  +      V%d  ",Tvar[j]);
          fprintf(ficlog,"  +      V%d  ",Tvar[j]);
- Line 2464  void powell(double p[], double **xi, int
+ Line 4239  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 2494  void powell(double p[], double **xi, int
+ Line 4272  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 2515  void powell(double p[], double **xi, int
+ Line 4296  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 2600  void powell(double p[], double **xi, int
+ Line 4383  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 2625  void powell(double p[], double **xi, int
+ Line 4414  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 2648  void powell(double p[], double **xi, int
+ Line 4437  void powell(double p[], double **xi, int
  #endif
  #ifdef POWELLORIGINAL
        if (t < 0.0) { /* Then we use it for new direction */
- #else
+ #else  /* Not POWELLOriginal but Brouard's */
        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);
        }
-       if (directest < 0.0) { /* Then we use it for new direction */
+       if (directest < 0.0) { /* Then we use (P0, Pn) for new direction Xi_n or Xi_iBig */
  #endif
  #ifdef DEBUGLINMIN
          printf("Before linmin in direction P%d-P0\n",n);
- Line 2689  void powell(double p[], double **xi, int
+ Line 4478  void powell(double p[], double **xi, int
            xi[j][ibig]=xi[j][n]; /* Replace direction with biggest decrease by last direction n */
            xi[j][n]=xit[j];      /* and this nth direction by the by the average p_0 p_n */
          }
+ /* #else */
+ /*      for (i=1;i<=n-1;i++) {  */
+ /*        for (j=1;j<=n;j++) {  */
+ /*          xi[j][i]=xi[j][i+1]; /\* Standard method of conjugate directions, not Powell who changes the nth direction by p0 pn . *\/ */
+ /*        } */
+ /*      } */
+ /*      for (j=1;j<=n;j++) {  */
+ /*        xi[j][n]=xit[j];      /\* and this nth direction by the by the average p_0 p_n *\/ */
+ /*      } */
+ /*      /\* for (j=1;j<=n-1;j++) {  *\/ */
+ /*      /\*   xi[j][1]=xi[j][j+1]; /\\* Standard method of conjugate directions *\\/ *\/ */
+ /*      /\*   xi[j][n]=xit[j];      /\\* and this nth direction by the by the average p_0 p_n *\\/ *\/ */
+ /*      /\* } *\/ */
+ /* #endif */
  #ifdef LINMINORIGINAL
  #else
          for (j=1, flatd=0;j<=n;j++) {
- Line 2713  void powell(double p[], double **xi, int
+ Line 4517  void powell(double p[], double **xi, int
            free_vector(pt,1,n);
            return;
  #endif
-         }
+         }  /* endif(flatd >0) */
- #endif
+ #endif /* LINMINORIGINAL */
          printf("Gaining to use new average direction of P0 P%d instead of biggest increase direction %d :\n",n,ibig);
          fprintf(ficlog,"Gaining to use new average direction of P0 P%d instead of biggest increase direction %d :\n",n,ibig);
- Line 2729  void powell(double p[], double **xi, int
+ Line 4533  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 2744  void powell(double p[], double **xi, int
+ Line 4550  void powell(double p[], double **xi, int
    double **prevalim(double **prlim, int nlstate, double x[], double age, double **oldm, double **savm, double ftolpl, int *ncvyear, int ij, int nres)
    {
-     /**< Computes the prevalence limit in each live state at age x and for covariate combination ij
+     /**< Computes the prevalence limit in each live state at age x and for covariate combination ij . Nicely done
       *   (and selected quantitative values in nres)
       *  by left multiplying the unit
       *  matrix by transitions matrix until convergence is reached with precision ftolpl
- Line 2769  void powell(double p[], double **xi, int
+ Line 4575  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;
+     int i, ii,j,k, k1;
    double *min, *max, *meandiff, maxmax,sumnew=0.;
    /* double **matprod2(); */ /* test */
    double **out, cov[NCOVMAX+1], **pmij(); /* **pmmij is a global variable feeded with oldms etc */
- Line 2800  void powell(double p[], double **xi, int
+ Line 4606  void powell(double p[], double **xi, int
       if(nagesqr==1){
        cov[3]= agefin*agefin;
       }
-     for (k=1; k<=nsd;k++) { /* For single dummy covariates only */
+      /* Model(2)  V1 + V2 + V3 + V8 + V7*V8 + V5*V6 + V8*age + V3*age + age*age */
-                         /* Here comes the value of the covariate 'ij' after renumbering k with single dummy covariates */
+      /* total number of covariates of the model nbocc(+)+1 = 8 excepting constant and age and age*age */
-       cov[2+nagesqr+TvarsDind[k]]=nbcode[TvarsD[k]][codtabm(ij,k)];
+      for(k1=1;k1<=cptcovt;k1++){ /* loop on model equation (including products) */
-       /* cov[++k1]=nbcode[TvarsD[k]][codtabm(ij,k)]; */
+        if(Typevar[k1]==1 || Typevar[k1]==3){ /* A product with age */
-       /* printf("prevalim Dummy combi=%d k=%d TvarsD[%d]=V%d TvarsDind[%d]=%d nbcode=%d cov=%lf codtabm(%d,Tvar[%d])=%d \n",ij,k, k, TvarsD[k],k,TvarsDind[k],nbcode[TvarsD[k]][codtabm(ij,k)],cov[2+nagesqr+TvarsDind[k]], ij, k, codtabm(ij,k)); */
+          cov[2+nagesqr+k1]=precov[nres][k1]*cov[2];
-     }
+        }else{
-     for (k=1; k<=nsq;k++) { /* For single varying covariates only */
+          cov[2+nagesqr+k1]=precov[nres][k1];
-                         /* Here comes the value of quantitative after renumbering k with single quantitative covariates */
+        }
-       cov[2+nagesqr+TvarsQind[k]]=Tqresult[nres][k];
+      }/* End of loop on model equation */
-       /* cov[++k1]=Tqresult[nres][k];  */
-       /* printf("prevalim Quantitative k=%d  TvarsQind[%d]=%d, TvarsQ[%d]=V%d,Tqresult[%d][%d]=%f\n",k,k,TvarsQind[k],k,TvarsQ[k],nres,k,Tqresult[nres][k]); */
+ /* Start of old code (replaced by a loop on position in the model equation */
-     }
+     /* for (k=1; k<=nsd;k++) { /\* For single dummy covariates only of the model *\/ */
-     for (k=1; k<=cptcovage;k++){  /* For product with age */
+     /*                  /\* Here comes the value of the covariate 'ij' after renumbering k with single dummy covariates *\/ */
-       if(Dummy[Tage[k]]==2){ /* dummy with age */
+     /*   /\* cov[2+nagesqr+TvarsDind[k]]=nbcode[TvarsD[k]][codtabm(ij,TvarsD[k])]; *\/ */
-         cov[2+nagesqr+Tage[k]]=nbcode[Tvar[Tage[k]]][codtabm(ij,k)]*cov[2];
+     /*   cov[2+nagesqr+TvarsDind[k]]=nbcode[TvarsD[k]][codtabm(ij,TnsdVar[TvarsD[k]])]; */
-         /* cov[++k1]=nbcode[Tvar[Tage[k]]][codtabm(ij,k)]*cov[2]; */
+     /*   /\* model = 1 +age + V1*V3 + age*V1 + V2 + V1 + age*V2 + V3 + V3*age + V1*V2  */
-       } else if(Dummy[Tage[k]]==3){ /* quantitative with age */
+     /*    * k                  1        2      3    4      5      6     7        8 */
-         cov[2+nagesqr+Tage[k]]=Tqresult[nres][k];
+     /*    *cov[]   1    2      3        4      5    6      7      8     9       10 */
-         /* cov[++k1]=Tqresult[nres][k];  */
+     /*    *TypeVar[k]          2        1      0    0      1      0     1        2 */
-       }
+     /*    *Dummy[k]            0        2      0    0      2      0     2        0 */
-       /* printf("prevalim Age combi=%d k=%d  Tage[%d]=V%d Tqresult[%d][%d]=%f\n",ij,k,k,Tage[k],nres,k,Tqresult[nres][k]); */
+     /*    *Tvar[k]             4        1      2    1      2      3     3        5 */
-     }
+     /*    *nsd=3                              (1)  (2)           (3) */
-     for (k=1; k<=cptcovprod;k++){ /* For product without age */
+     /*    *TvarsD[nsd]                      [1]=2    1             3 */
-       /* printf("prevalim Prod ij=%d k=%d  Tprod[%d]=%d Tvard[%d][1]=V%d, Tvard[%d][2]=V%d\n",ij,k,k,Tprod[k], k,Tvard[k][1], k,Tvard[k][2]); */
+     /*    *TnsdVar                          [2]=2 [1]=1         [3]=3 */
-       if(Dummy[Tvard[k][1]==0]){
+     /*    *TvarsDind[nsd](=k)               [1]=3 [2]=4         [3]=6 */
-         if(Dummy[Tvard[k][2]==0]){
+     /*    *Tage[]                  [1]=1                  [2]=2      [3]=3 */
-           cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)] * nbcode[Tvard[k][2]][codtabm(ij,k)];
+     /*    *Tvard[]       [1][1]=1                                           [2][1]=1 */
-           /* cov[++k1]=nbcode[Tvard[k][1]][codtabm(ij,k)] * nbcode[Tvard[k][2]][codtabm(ij,k)]; */
+     /*    *                   [1][2]=3                                           [2][2]=2 */
-         }else{
+     /*    *Tprod[](=k)     [1]=1                                              [2]=8 */
-           cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)] * Tqresult[nres][k];
+     /*    *TvarsDp(=Tvar)   [1]=1            [2]=2             [3]=3          [4]=5 */
-           /* cov[++k1]=nbcode[Tvard[k][1]][codtabm(ij,k)] * Tqresult[nres][k]; */
+     /*    *TvarD (=k)       [1]=1            [2]=3 [3]=4       [3]=6          [4]=6 */
-         }
+     /*    *TvarsDpType */
-       }else{
+     /*    *si model= 1 + age + V3 + V2*age + V2 + V3*age */
-         if(Dummy[Tvard[k][2]==0]){
+     /*    * nsd=1              (1)           (2) */
-           cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][2]][codtabm(ij,k)] * Tqinvresult[nres][Tvard[k][1]];
+     /*    *TvarsD[nsd]          3             2 */
-           /* cov[++k1]=nbcode[Tvard[k][2]][codtabm(ij,k)] * Tqinvresult[nres][Tvard[k][1]]; */
+     /*    *TnsdVar           (3)=1          (2)=2 */
-         }else{
+     /*    *TvarsDind[nsd](=k)  [1]=1        [2]=3 */
-           cov[2+nagesqr+Tprod[k]]=Tqinvresult[nres][Tvard[k][1]]*  Tqinvresult[nres][Tvard[k][2]];
+     /*    *Tage[]                  [1]=2           [2]= 3    */
-           /* cov[++k1]=Tqinvresult[nres][Tvard[k][1]]*  Tqinvresult[nres][Tvard[k][2]]; */
+     /*    *\/ */
-         }
+     /*   /\* cov[++k1]=nbcode[TvarsD[k]][codtabm(ij,k)]; *\/ */
-       }
+     /*   /\* printf("prevalim Dummy combi=%d k=%d TvarsD[%d]=V%d TvarsDind[%d]=%d nbcode=%d cov=%lf codtabm(%d,Tvar[%d])=%d \n",ij,k, k, TvarsD[k],k,TvarsDind[k],nbcode[TvarsD[k]][codtabm(ij,k)],cov[2+nagesqr+TvarsDind[k]], ij, k, codtabm(ij,k)); *\/ */
-     }
+     /* } */
+     /* for (k=1; k<=nsq;k++) { /\* For single quantitative varying covariates only of the model *\/ */
+     /*                  /\* Here comes the value of quantitative after renumbering k with single quantitative covariates *\/ */
+     /*   /\* Tqresult[nres][result_position]= value of the variable at the result_position in the nres resultline                                 *\/ */
+     /*   /\* cov[2+nagesqr+TvarsQind[k]]=Tqresult[nres][k]; *\/ */
+     /*   cov[2+nagesqr+TvarsQind[k]]=Tqresult[nres][resultmodel[nres][k1]] */
+     /*   /\* cov[++k1]=Tqresult[nres][k];  *\/ */
+     /*   /\* printf("prevalim Quantitative k=%d  TvarsQind[%d]=%d, TvarsQ[%d]=V%d,Tqresult[%d][%d]=%f\n",k,k,TvarsQind[k],k,TvarsQ[k],nres,k,Tqresult[nres][k]); *\/ */
+     /* } */
+     /* for (k=1; k<=cptcovage;k++){  /\* For product with age *\/ */
+     /*   if(Dummy[Tage[k]]==2){ /\* dummy with age *\/ */
+     /*  cov[2+nagesqr+Tage[k]]=nbcode[Tvar[Tage[k]]][codtabm(ij,Tvar[Tage[k]])]*cov[2]; */
+     /*  /\* cov[++k1]=nbcode[Tvar[Tage[k]]][codtabm(ij,k)]*cov[2]; *\/ */
+     /*   } else if(Dummy[Tage[k]]==3){ /\* quantitative with age *\/ */
+     /*  cov[2+nagesqr+Tage[k]]=Tqresult[nres][k]; */
+     /*  /\* cov[++k1]=Tqresult[nres][k];  *\/ */
+     /*   } */
+     /*   /\* printf("prevalim Age combi=%d k=%d  Tage[%d]=V%d Tqresult[%d][%d]=%f\n",ij,k,k,Tage[k],nres,k,Tqresult[nres][k]); *\/ */
+     /* } */
+     /* for (k=1; k<=cptcovprod;k++){ /\* For product without age *\/ */
+     /*   /\* printf("prevalim Prod ij=%d k=%d  Tprod[%d]=%d Tvard[%d][1]=V%d, Tvard[%d][2]=V%d\n",ij,k,k,Tprod[k], k,Tvard[k][1], k,Tvard[k][2]); *\/ */
+     /*   if(Dummy[Tvard[k][1]]==0){ */
+     /*  if(Dummy[Tvard[k][2]]==0){ */
+     /*    cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,Tvard[k][1])] * nbcode[Tvard[k][2]][codtabm(ij,Tvard[k][2])]; */
+     /*    /\* cov[++k1]=nbcode[Tvard[k][1]][codtabm(ij,k)] * nbcode[Tvard[k][2]][codtabm(ij,k)]; *\/ */
+     /*  }else{ */
+     /*    cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,Tvard[k][1])] * Tqresult[nres][k]; */
+     /*    /\* cov[++k1]=nbcode[Tvard[k][1]][codtabm(ij,k)] * Tqresult[nres][k]; *\/ */
+     /*  } */
+     /*   }else{ */
+     /*  if(Dummy[Tvard[k][2]]==0){ */
+     /*    cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][2]][codtabm(ij,Tvard[k][2])] * Tqinvresult[nres][Tvard[k][1]]; */
+     /*    /\* cov[++k1]=nbcode[Tvard[k][2]][codtabm(ij,k)] * Tqinvresult[nres][Tvard[k][1]]; *\/ */
+     /*  }else{ */
+     /*    cov[2+nagesqr+Tprod[k]]=Tqinvresult[nres][Tvard[k][1]]*  Tqinvresult[nres][Tvard[k][2]]; */
+     /*    /\* cov[++k1]=Tqinvresult[nres][Tvard[k][1]]*  Tqinvresult[nres][Tvard[k][2]]; *\/ */
+     /*  } */
+     /*   } */
+     /* } /\* End product without age *\/ */
+ /* ENd of old code */
      /*printf("ij=%d cptcovprod=%d tvar=%d ", ij, cptcovprod, Tvar[1]);*/
      /*printf("ij=%d cov[3]=%lf cov[4]=%lf \n",ij, cov[3],cov[4]);*/
      /*printf("ij=%d cov[3]=%lf \n",ij, cov[3]);*/
- Line 2898  void powell(double p[], double **xi, int
+ Line 4743  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 2933  void powell(double p[], double **xi, int
+ Line 4780  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;
+   int i, ii,j, k1;
    int first=0;
    double *min, *max, *meandiff, maxmax,sumnew=0.;
    /* double **matprod2(); */ /* test */
- Line 2973  void powell(double p[], double **xi, int
+ Line 4820  void powell(double p[], double **xi, int
      if(nagesqr==1){
        cov[3]= agefin*agefin;;
      }
-     for (k=1; k<=nsd;k++) { /* For single dummy covariates only */
+     for(k1=1;k1<=cptcovt;k1++){ /* loop on model equation (including products) */
-                         /* Here comes the value of the covariate 'ij' after renumbering k with single dummy covariates */
+       if(Typevar[k1]==1 || Typevar[k1]==3){ /* A product with age */
-       cov[2+nagesqr+TvarsDind[k]]=nbcode[TvarsD[k]][codtabm(ij,k)];
+         cov[2+nagesqr+k1]=precov[nres][k1]*cov[2];
-       /* printf("bprevalim Dummy agefin=%.0f combi=%d k=%d TvarsD[%d]=V%d TvarsDind[%d]=%d nbcode=%d cov[%d]=%lf codtabm(%d,Tvar[%d])=%d \n",agefin,ij,k, k, TvarsD[k],k,TvarsDind[k],nbcode[TvarsD[k]][codtabm(ij,k)],2+nagesqr+TvarsDind[k],cov[2+nagesqr+TvarsDind[k]], ij, k, codtabm(ij,k)); */
-     }
-     /* for (k=1; k<=cptcovn;k++) { */
-     /*   /\* cov[2+nagesqr+k]=nbcode[Tvar[k]][codtabm(ij,Tvar[k])]; *\/ */
-     /*   cov[2+nagesqr+k]=nbcode[Tvar[k]][codtabm(ij,k)]; */
-     /*   /\* printf("prevalim ij=%d k=%d Tvar[%d]=%d nbcode=%d cov=%lf codtabm(%d,Tvar[%d])=%d \n",ij,k, k, Tvar[k],nbcode[Tvar[k]][codtabm(ij,Tvar[k])],cov[2+k], ij, k, codtabm(ij,Tvar[k])]); *\/ */
-     /* } */
-     for (k=1; k<=nsq;k++) { /* For single varying covariates only */
-                         /* Here comes the value of quantitative after renumbering k with single quantitative covariates */
-       cov[2+nagesqr+TvarsQind[k]]=Tqresult[nres][k];
-       /* printf("prevalim Quantitative k=%d  TvarsQind[%d]=%d, TvarsQ[%d]=V%d,Tqresult[%d][%d]=%f\n",k,k,TvarsQind[k],k,TvarsQ[k],nres,k,Tqresult[nres][k]); */
-     }
-     /* for (k=1; k<=cptcovage;k++) cov[2+nagesqr+Tage[k]]=nbcode[Tvar[k]][codtabm(ij,k)]*cov[2]; */
-     /* for (k=1; k<=cptcovprod;k++) /\* Useless *\/ */
-     /*   /\* cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,Tvard[k][1])] * nbcode[Tvard[k][2]][codtabm(ij,Tvard[k][2])]; *\/ */
-     /*   cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)] * nbcode[Tvard[k][2]][codtabm(ij,k)]; */
-     for (k=1; k<=cptcovage;k++){  /* For product with age */
-       /* if(Dummy[Tvar[Tage[k]]]== 2){ /\* dummy with age *\/ ERROR ???*/
-       if(Dummy[Tage[k]]== 2){ /* dummy with age */
-         cov[2+nagesqr+Tage[k]]=nbcode[Tvar[Tage[k]]][codtabm(ij,k)]*cov[2];
-       } else if(Dummy[Tage[k]]== 3){ /* quantitative with age */
-         cov[2+nagesqr+Tage[k]]=Tqresult[nres][k];
-       }
-       /* printf("prevalim Age combi=%d k=%d  Tage[%d]=V%d Tqresult[%d][%d]=%f\n",ij,k,k,Tage[k],nres,k,Tqresult[nres][k]); */
-     }
-     for (k=1; k<=cptcovprod;k++){ /* For product without age */
-       /* printf("prevalim Prod ij=%d k=%d  Tprod[%d]=%d Tvard[%d][1]=V%d, Tvard[%d][2]=V%d\n",ij,k,k,Tprod[k], k,Tvard[k][1], k,Tvard[k][2]); */
-       if(Dummy[Tvard[k][1]==0]){
-         if(Dummy[Tvard[k][2]==0]){
-           cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)] * nbcode[Tvard[k][2]][codtabm(ij,k)];
-         }else{
-           cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)] * Tqresult[nres][k];
-         }
        }else{
-         if(Dummy[Tvard[k][2]==0]){
+         cov[2+nagesqr+k1]=precov[nres][k1];
-           cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][2]][codtabm(ij,k)] * Tqinvresult[nres][Tvard[k][1]];
-         }else{
-           cov[2+nagesqr+Tprod[k]]=Tqinvresult[nres][Tvard[k][1]]*  Tqinvresult[nres][Tvard[k][2]];
-         }
        }
-     }
+     }/* End of loop on model equation */
+ /* Old code */
+     /* for (k=1; k<=nsd;k++) { /\* For single dummy covariates only *\/ */
+     /*                  /\* Here comes the value of the covariate 'ij' after renumbering k with single dummy covariates *\/ */
+     /*   cov[2+nagesqr+TvarsDind[k]]=nbcode[TvarsD[k]][codtabm(ij,TvarsD[k])]; */
+     /*   /\* printf("bprevalim Dummy agefin=%.0f combi=%d k=%d TvarsD[%d]=V%d TvarsDind[%d]=%d nbcode=%d cov[%d]=%lf codtabm(%d,Tvar[%d])=%d \n",agefin,ij,k, k, TvarsD[k],k,TvarsDind[k],nbcode[TvarsD[k]][codtabm(ij,k)],2+nagesqr+TvarsDind[k],cov[2+nagesqr+TvarsDind[k]], ij, k, codtabm(ij,k)); *\/ */
+     /* } */
+     /* /\* for (k=1; k<=cptcovn;k++) { *\/ */
+     /* /\*   /\\* cov[2+nagesqr+k]=nbcode[Tvar[k]][codtabm(ij,Tvar[k])]; *\\/ *\/ */
+     /* /\*   cov[2+nagesqr+k]=nbcode[Tvar[k]][codtabm(ij,k)]; *\/ */
+     /* /\*   /\\* printf("prevalim ij=%d k=%d Tvar[%d]=%d nbcode=%d cov=%lf codtabm(%d,Tvar[%d])=%d \n",ij,k, k, Tvar[k],nbcode[Tvar[k]][codtabm(ij,Tvar[k])],cov[2+k], ij, k, codtabm(ij,Tvar[k])]); *\\/ *\/ */
+     /* /\* } *\/ */
+     /* for (k=1; k<=nsq;k++) { /\* For single varying covariates only *\/ */
+     /*                  /\* Here comes the value of quantitative after renumbering k with single quantitative covariates *\/ */
+     /*   cov[2+nagesqr+TvarsQind[k]]=Tqresult[nres][k];  */
+     /*   /\* printf("prevalim Quantitative k=%d  TvarsQind[%d]=%d, TvarsQ[%d]=V%d,Tqresult[%d][%d]=%f\n",k,k,TvarsQind[k],k,TvarsQ[k],nres,k,Tqresult[nres][k]); *\/ */
+     /* } */
+     /* /\* for (k=1; k<=cptcovage;k++) cov[2+nagesqr+Tage[k]]=nbcode[Tvar[k]][codtabm(ij,k)]*cov[2]; *\/ */
+     /* /\* for (k=1; k<=cptcovprod;k++) /\\* Useless *\\/ *\/ */
+     /* /\*   /\\* cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,Tvard[k][1])] * nbcode[Tvard[k][2]][codtabm(ij,Tvard[k][2])]; *\\/ *\/ */
+     /* /\*   cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)] * nbcode[Tvard[k][2]][codtabm(ij,k)]; *\/ */
+     /* for (k=1; k<=cptcovage;k++){  /\* For product with age *\/ */
+     /*   /\* if(Dummy[Tvar[Tage[k]]]== 2){ /\\* dummy with age *\\/ ERROR ???*\/ */
+     /*   if(Dummy[Tage[k]]== 2){ /\* dummy with age *\/ */
+     /*  cov[2+nagesqr+Tage[k]]=nbcode[Tvar[Tage[k]]][codtabm(ij,Tvar[Tage[k]])]*cov[2]; */
+     /*   } else if(Dummy[Tage[k]]== 3){ /\* quantitative with age *\/ */
+     /*  cov[2+nagesqr+Tage[k]]=Tqresult[nres][k]; */
+     /*   } */
+     /*   /\* printf("prevalim Age combi=%d k=%d  Tage[%d]=V%d Tqresult[%d][%d]=%f\n",ij,k,k,Tage[k],nres,k,Tqresult[nres][k]); *\/ */
+     /* } */
+     /* for (k=1; k<=cptcovprod;k++){ /\* For product without age *\/ */
+     /*   /\* printf("prevalim Prod ij=%d k=%d  Tprod[%d]=%d Tvard[%d][1]=V%d, Tvard[%d][2]=V%d\n",ij,k,k,Tprod[k], k,Tvard[k][1], k,Tvard[k][2]); *\/ */
+     /*   if(Dummy[Tvard[k][1]]==0){ */
+     /*  if(Dummy[Tvard[k][2]]==0){ */
+     /*    cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,Tvard[k][1])] * nbcode[Tvard[k][2]][codtabm(ij,Tvard[k][2])]; */
+     /*  }else{ */
+     /*    cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,Tvard[k][1])] * Tqresult[nres][k]; */
+     /*  } */
+     /*   }else{ */
+     /*  if(Dummy[Tvard[k][2]]==0){ */
+     /*    cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][2]][codtabm(ij,Tvard[k][2])] * Tqinvresult[nres][Tvard[k][1]]; */
+     /*  }else{ */
+     /*    cov[2+nagesqr+Tprod[k]]=Tqinvresult[nres][Tvard[k][1]]*  Tqinvresult[nres][Tvard[k][2]]; */
+     /*  } */
+     /*   } */
+     /* } */
      /*printf("ij=%d cptcovprod=%d tvar=%d ", ij, cptcovprod, Tvar[1]);*/
      /*printf("ij=%d cov[3]=%lf cov[4]=%lf \n",ij, cov[3],cov[4]);*/
- Line 3127  double **pmij(double **ps, double *cov,
+ Line 4984  double **pmij(double **ps, double *cov,
          /*       printf("Int j<i s1=%.17e, lnpijopii=%.17e\n",s1,lnpijopii); */
        }
        ps[i][j]=lnpijopii; /* In fact ln(pij/pii) */
-       /*        printf("s1=%.17e, lnpijopii=%.17e\n",s1,lnpijopii); */
+       /* printf("Debug pmij() i=%d j=%d nc=%d s1=%.17f, lnpijopii=%.17f\n",i,j,nc, s1,lnpijopii); */
      }
      for(j=i+1; j<=nlstate+ndeath;j++){
        for (nc=1, lnpijopii=0.;nc <=ncovmodel; nc++){
- Line 3136  double **pmij(double **ps, double *cov,
+ Line 4993  double **pmij(double **ps, double *cov,
          /*        printf("Int j>i s1=%.17e, lnpijopii=%.17e %lx %lx\n",s1,lnpijopii,s1,lnpijopii); */
        }
        ps[i][j]=lnpijopii; /* In fact ln(pij/pii) */
+       /* printf("Debug pmij() i=%d j=%d nc=%d s1=%.17f, lnpijopii=%.17f\n",i,j,nc, s1,lnpijopii); */
      }
    }
    for(i=1; i<= nlstate; i++){
      s1=0;
      for(j=1; j<i; j++){
+       /* printf("debug1 %d %d ps=%lf exp(ps)=%lf \n",i,j,ps[i][j],exp(ps[i][j])); */
        s1+=exp(ps[i][j]); /* In fact sums pij/pii */
-       /*printf("debug1 %d %d ps=%lf exp(ps)=%lf s1+=%lf\n",i,j,ps[i][j],exp(ps[i][j]),s1); */
      }
      for(j=i+1; j<=nlstate+ndeath; j++){
+       /* printf("debug2 %d %d ps=%lf exp(ps)=%lf \n",i,j,ps[i][j],exp(ps[i][j])); */
        s1+=exp(ps[i][j]); /* In fact sums pij/pii */
-       /*printf("debug2 %d %d ps=%lf exp(ps)=%lf s1+=%lf\n",i,j,ps[i][j],exp(ps[i][j]),s1); */
      }
      /* s1= sum_{j<>i} pij/pii=(1-pii)/pii and thus pii is known from s1 */
      ps[i][i]=1./(s1+1.);
- Line 3189  double **pmij(double **ps, double *cov,
+ Line 5047  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 3391  double **matprod2(double **out, double *
+ Line 5249  double **matprod2(double **out, double *
  double ***hpxij(double ***po, int nhstepm, double age, int hstepm, double *x, int nlstate, int stepm, double **oldm, double **savm, int ij, int nres )
  {
-   /* Computes the transition matrix starting at age 'age' and combination of covariate values corresponding to ij over
+   /* Already optimized with precov.
+      Computes the transition matrix starting at age 'age' and dummies values in each resultline (loop on ij to find the corresponding combination) to over
       'nhstepm*hstepm*stepm' months (i.e. until
       age (in years)  age+nhstepm*hstepm*stepm/12) by multiplying
       nhstepm*hstepm matrices.
- Line 3403  double ***hpxij(double ***po, int nhstep
+ Line 5262  double ***hpxij(double ***po, int nhstep
       */
-   int i, j, d, h, k;
+   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 3426  double ***hpxij(double ***po, int nhstep
+ Line 5285  double ***hpxij(double ***po, int nhstep
        if(nagesqr==1){
          cov[3]= agexact*agexact;
        }
-       for (k=1; k<=nsd;k++) { /* For single dummy covariates only */
+       /* Model(2)  V1 + V2 + V3 + V8 + V7*V8 + V5*V6 + V8*age + V3*age + age*age */
- /* Here comes the value of the covariate 'ij' after renumbering k with single dummy covariates */
+       /* total number of covariates of the model nbocc(+)+1 = 8 excepting constant and age and age*age */
-         /* codtabm(ij,k)  (1 & (ij-1) >> (k-1))+1 */
+       for(k1=1;k1<=cptcovt;k1++){ /* loop on model equation (including products) */
- /*             V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */
+         if(Typevar[k1]==1 || Typevar[k1]==3){ /* A product with age */
- /*    k        1  2   3   4     5    6    7     8    9 */
+           cov[2+nagesqr+k1]=precov[nres][k1]*cov[2];
- /*Tvar[k]=     5  4   3   6     5    2    7     1    1 */
- /*    nsd         1   2                              3 */ /* Counting single dummies covar fixed or tv */
- /*TvarsD[nsd]     4   3                              1 */ /* ID of single dummy cova fixed or timevary*/
- /*TvarsDind[k]    2   3                              9 */ /* position K of single dummy cova */
-         cov[2+nagesqr+TvarsDind[k]]=nbcode[TvarsD[k]][codtabm(ij,k)];
-         /* printf("hpxij Dummy combi=%d k=%d TvarsD[%d]=V%d TvarsDind[%d]=%d nbcode=%d cov=%lf codtabm(%d,Tvar[%d])=%d \n",ij,k, k, TvarsD[k],k,TvarsDind[k],nbcode[TvarsD[k]][codtabm(ij,k)],cov[2+nagesqr+TvarsDind[k]], ij, k, codtabm(ij,k)); */
-       }
-       for (k=1; k<=nsq;k++) { /* For single varying covariates only */
-         /* Here comes the value of quantitative after renumbering k with single quantitative covariates */
-         cov[2+nagesqr+TvarsQind[k]]=Tqresult[nres][k];
-         /* printf("hPxij Quantitative k=%d  TvarsQind[%d]=%d, TvarsQ[%d]=V%d,Tqresult[%d][%d]=%f\n",k,k,TvarsQind[k],k,TvarsQ[k],nres,k,Tqresult[nres][k]); */
-       }
-       for (k=1; k<=cptcovage;k++){ /* For product with age V1+V1*age +V4 +age*V3 */
-         /* 1+2 Tage[1]=2 TVar[2]=1 Dummy[2]=2, Tage[2]=4 TVar[4]=3 Dummy[4]=3 quant*/
-         /* */
-         if(Dummy[Tage[k]]== 2){ /* dummy with age */
-         /* if(Dummy[Tvar[Tage[k]]]== 2){ /\* dummy with age *\/ */
-           cov[2+nagesqr+Tage[k]]=nbcode[Tvar[Tage[k]]][codtabm(ij,k)]*cov[2];
-         } else if(Dummy[Tage[k]]== 3){ /* quantitative with age */
-           cov[2+nagesqr+Tage[k]]=Tqresult[nres][k];
-         }
-         /* printf("hPxij Age combi=%d k=%d  Tage[%d]=V%d Tqresult[%d][%d]=%f\n",ij,k,k,Tage[k],nres,k,Tqresult[nres][k]); */
-       }
-       for (k=1; k<=cptcovprod;k++){ /*  For product without age */
-         /* printf("hPxij Prod ij=%d k=%d  Tprod[%d]=%d Tvard[%d][1]=V%d, Tvard[%d][2]=V%d\n",ij,k,k,Tprod[k], k,Tvard[k][1], k,Tvard[k][2]); */
-         /* cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)] * nbcode[Tvard[k][2]][codtabm(ij,k)]; */
-         if(Dummy[Tvard[k][1]==0]){
-           if(Dummy[Tvard[k][2]==0]){
-             cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)] * nbcode[Tvard[k][2]][codtabm(ij,k)];
-           }else{
-             cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)] * Tqresult[nres][k];
-           }
          }else{
-           if(Dummy[Tvard[k][2]==0]){
+           cov[2+nagesqr+k1]=precov[nres][k1];
-             cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][2]][codtabm(ij,k)] * Tqinvresult[nres][Tvard[k][1]];
-           }else{
-             cov[2+nagesqr+Tprod[k]]=Tqinvresult[nres][Tvard[k][1]]*  Tqinvresult[nres][Tvard[k][2]];
-           }
          }
-       }
+       }/* End of loop on model equation */
+         /* Old code */
+ /*      if( Dummy[k1]==0 && Typevar[k1]==0 ){ /\* Single dummy  *\/ */
+ /* /\*     V(Tvarsel)=Tvalsel=Tresult[nres][pos](value); V(Tvresult[nres][pos] (variable): V(variable)=value) *\/ */
+ /* /\*       for (k=1; k<=nsd;k++) { /\\* For single dummy covariates only *\\/ *\/ */
+ /* /\* /\\* Here comes the value of the covariate 'ij' after renumbering k with single dummy covariates *\\/ *\/ */
+ /*      /\* codtabm(ij,k)  (1 & (ij-1) >> (k-1))+1 *\/ */
+ /* /\*             V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 *\/ */
+ /* /\*    k        1  2   3   4     5    6    7     8    9 *\/ */
+ /* /\*Tvar[k]=     5  4   3   6     5    2    7     1    1 *\/ */
+ /* /\*    nsd         1   2                              3 *\/ /\* Counting single dummies covar fixed or tv *\/ */
+ /* /\*TvarsD[nsd]     4   3                              1 *\/ /\* ID of single dummy cova fixed or timevary*\/ */
+ /* /\*TvarsDind[k]    2   3                              9 *\/ /\* position K of single dummy cova *\/ */
+ /*        /\* cov[2+nagesqr+TvarsDind[k]]=nbcode[TvarsD[k]][codtabm(ij,k)];or [codtabm(ij,TnsdVar[TvarsD[k]] *\/ */
+ /*        cov[2+nagesqr+k1]=Tresult[nres][resultmodel[nres][k1]]; */
+ /*        /\* printf("hpxij Dummy combi=%d k=%d TvarsD[%d]=V%d TvarsDind[%d]=%d nbcode=%d cov=%lf codtabm(%d,TnsdVar[TvarsD[%d])=%d \n",ij,k, k, TvarsD[k],k,TvarsDind[k],nbcode[TvarsD[k]][codtabm(ij,TnsdVar[TvarsD[k]])],cov[2+nagesqr+TvarsDind[k]], ij, k, codtabm(ij,TnsdVar[TvarsD[k]])); *\/ */
+ /*        printf("hpxij Dummy combi=%d k1=%d Tvar[%d]=V%d cov[2+%d+%d]=%lf resultmodel[nres][%d]=%d nres/nresult=%d/%d \n",ij,k1,k1, Tvar[k1],nagesqr,k1,cov[2+nagesqr+k1],k1,resultmodel[nres][k1],nres,nresult); */
+ /*        printf("hpxij new Dummy precov[nres=%d][k1=%d]=%.4f\n", nres, k1, precov[nres][k1]); */
+ /*      }else if( Dummy[k1]==1 && Typevar[k1]==0 ){ /\* Single quantitative variables  *\/ */
+ /*        /\* resultmodel[nres][k1]=k3: k1th position in the model correspond to the k3 position in the resultline *\/ */
+ /*        cov[2+nagesqr+k1]=Tqresult[nres][resultmodel[nres][k1]];  */
+ /*        /\* for (k=1; k<=nsq;k++) { /\\* For single varying covariates only *\\/ *\/ */
+ /*        /\*   /\\* Here comes the value of quantitative after renumbering k with single quantitative covariates *\\/ *\/ */
+ /*        /\*   cov[2+nagesqr+TvarsQind[k]]=Tqresult[nres][k]; *\/ */
+ /*        printf("hPxij Quantitative k1=%d resultmodel[nres][%d]=%d,Tqresult[%d][%d]=%f\n",k1,k1,resultmodel[nres][k1],nres,resultmodel[nres][k1],Tqresult[nres][resultmodel[nres][k1]]); */
+ /*        printf("hpxij new Quanti precov[nres=%d][k1=%d]=%.4f\n", nres, k1, precov[nres][k1]); */
+ /*      }else if( Dummy[k1]==2 ){ /\* For dummy with age product *\/ */
+ /*        /\* Tvar[k1] Variable in the age product age*V1 is 1 *\/ */
+ /*        /\* [Tinvresult[nres][V1] is its value in the resultline nres *\/ */
+ /*        cov[2+nagesqr+k1]=TinvDoQresult[nres][Tvar[k1]]*cov[2]; */
+ /*        printf("DhPxij Dummy with age k1=%d Tvar[%d]=%d TinvDoQresult[nres=%d][%d]=%.f age=%.2f,cov[2+%d+%d]=%.3f\n",k1,k1,Tvar[k1],nres,TinvDoQresult[nres][Tvar[k1]],cov[2],nagesqr,k1,cov[2+nagesqr+k1]); */
+ /*        printf("hpxij new Dummy with age product precov[nres=%d][k1=%d]=%.4f * age=%.2f\n", nres, k1, precov[nres][k1], cov[2]); */
+ /*        /\* cov[2+nagesqr+k1]=Tresult[nres][resultmodel[nres][k1]];    *\/ */
+ /*        /\* for (k=1; k<=cptcovage;k++){ /\\* For product with age V1+V1*age +V4 +age*V3 *\\/ *\/ */
+ /*        /\* 1+2 Tage[1]=2 TVar[2]=1 Dummy[2]=2, Tage[2]=4 TVar[4]=3 Dummy[4]=3 quant*\/ */
+ /*        /\* *\/ */
+ /* /\*             V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 *\/ */
+ /* /\*    k        1  2   3   4     5    6    7     8    9 *\/ */
+ /* /\*Tvar[k]=     5  4   3   6     5    2    7     1    1 *\/ */
+ /* /\*cptcovage=2                   1               2      *\/ */
+ /* /\*Tage[k]=                      5               8      *\/   */
+ /*      }else if( Dummy[k1]==3 ){ /\* For quant with age product *\/ */
+ /*        cov[2+nagesqr+k1]=Tresult[nres][resultmodel[nres][k1]];        */
+ /*        printf("QhPxij Quant with age k1=%d resultmodel[nres][%d]=%d,Tqresult[%d][%d]=%f\n",k1,k1,resultmodel[nres][k1],nres,resultmodel[nres][k1],Tqresult[nres][resultmodel[nres][k1]]); */
+ /*        printf("hpxij new Quanti with age product precov[nres=%d][k1=%d] * age=%.2f\n", nres, k1, precov[nres][k1], cov[2]); */
+ /*        /\* if(Dummy[Tage[k]]== 2){ /\\* dummy with age *\\/ *\/ */
+ /*        /\* /\\* if(Dummy[Tvar[Tage[k]]]== 2){ /\\\* dummy with age *\\\/ *\\/ *\/ */
+ /*        /\*   /\\* cov[2+nagesqr+Tage[k]]=nbcode[Tvar[Tage[k]]][codtabm(ij,k)]*cov[2]; *\\/ *\/ */
+ /*        /\*   /\\* cov[2+nagesqr+Tage[k]]=nbcode[Tvar[Tage[k]]][codtabm(ij,TnsdVar[TvarsD[Tvar[Tage[k]]]])]*cov[2]; *\\/ *\/ */
+ /*        /\*   cov[2+nagesqr+Tage[k]]=nbcode[Tvar[Tage[k]]][codtabm(ij,TnsdVar[TvarsD[Tvar[Tage[k]]]])]*cov[2]; *\/ */
+ /*        /\*   printf("hPxij Age combi=%d k=%d cptcovage=%d Tage[%d]=%d Tvar[Tage[%d]]=V%d nbcode[Tvar[Tage[k]]][codtabm(ij,TnsdVar[Tvar[Tage[k]]]])]=%d nres=%d\n",ij,k,cptcovage,k,Tage[k],k,Tvar[Tage[k]], nbcode[Tvar[Tage[k]]][codtabm(ij,TnsdVar[Tvar[Tage[k]]])],nres); *\/ */
+ /*        /\* } else if(Dummy[Tage[k]]== 3){ /\\* quantitative with age *\\/ *\/ */
+ /*        /\*   cov[2+nagesqr+Tage[k]]=Tqresult[nres][k]; *\/ */
+ /*        /\* } *\/ */
+ /*        /\* printf("hPxij Age combi=%d k=%d  Tage[%d]=V%d Tqresult[%d][%d]=%f\n",ij,k,k,Tage[k],nres,k,Tqresult[nres][k]); *\/ */
+ /*      }else if(Typevar[k1]==2 ){ /\* For product (not with age) *\/ */
+ /* /\*       for (k=1; k<=cptcovprod;k++){ /\\*  For product without age *\\/ *\/ */
+ /* /\* /\\*             V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 *\\/ *\/ */
+ /* /\* /\\*    k        1  2   3   4     5    6    7     8    9 *\\/ *\/ */
+ /* /\* /\\*Tvar[k]=     5  4   3   6     5    2    7     1    1 *\\/ *\/ */
+ /* /\* /\\*cptcovprod=1            1               2            *\\/ *\/ */
+ /* /\* /\\*Tprod[]=                4               7            *\\/ *\/ */
+ /* /\* /\\*Tvard[][1]             4               1             *\\/ *\/ */
+ /* /\* /\\*Tvard[][2]               3               2           *\\/ *\/ */
+ /*        /\* printf("hPxij Prod ij=%d k=%d  Tprod[%d]=%d Tvard[%d][1]=V%d, Tvard[%d][2]=V%d nbcode[Tvard[k][1]][codtabm(ij,Tvard[k][1])]=%d nbcode[Tvard[k][2]][codtabm(ij,Tvard[k][1])]=%d\n",ij,k,k,Tprod[k], k,Tvard[k][1], k,Tvard[k][2],nbcode[Tvard[k][1]][codtabm(ij,Tvard[k][1])],nbcode[Tvard[k][2]][codtabm(ij,Tvard[k][2])]); *\/ */
+ /*        /\* cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)] * nbcode[Tvard[k][2]][codtabm(ij,k)]; *\/ */
+ /*        cov[2+nagesqr+k1]=TinvDoQresult[nres][Tvardk[k1][1]] * TinvDoQresult[nres][Tvardk[k1][2]];     */
+ /*        printf("hPxij Prod ij=%d k1=%d  cov[2+%d+%d]=%.5f Tvard[%d][1]=V%d * Tvard[%d][2]=V%d ; TinvDoQresult[nres][Tvardk[k1][1]]=%.4f * TinvDoQresult[nres][Tvardk[k1][1]]=%.4f\n",ij,k1,nagesqr,k1,cov[2+nagesqr+k1],k1,Tvardk[k1][1], k1,Tvardk[k1][2], TinvDoQresult[nres][Tvardk[k1][1]], TinvDoQresult[nres][Tvardk[k1][2]]); */
+ /*        printf("hpxij new Product no age product precov[nres=%d][k1=%d]=%.4f\n", nres, k1, precov[nres][k1]); */
+ /*        /\* if(Dummy[Tvardk[k1][1]]==0){ *\/ */
+ /*        /\*   if(Dummy[Tvardk[k1][2]]==0){ /\\* Product of dummies *\\/ *\/ */
+ /*            /\* cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)] * nbcode[Tvard[k][2]][codtabm(ij,k)]; *\/ */
+ /*            /\* cov[2+nagesqr+k1]=Tinvresult[nres][Tvardk[k1][1]] * Tinvresult[nres][Tvardk[k1][2]];   *\/ */
+ /*            /\* cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,TnsdVar[Tvard[k][1]])] * nbcode[Tvard[k][2]][codtabm(ij,TnsdVar[Tvard[k][2]])]; *\/ */
+ /*          /\* }else{ /\\* Product of dummy by quantitative *\\/ *\/ */
+ /*            /\* cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,TnsdVar[Tvard[k][1]])] * Tqresult[nres][k]; *\/ */
+ /*            /\* cov[2+nagesqr+k1]=Tresult[nres][Tinvresult[nres][Tvardk[k1][1]]] * Tqresult[nres][Tinvresult[nres][Tvardk[k1][2]]]; *\/ */
+ /*        /\*   } *\/ */
+ /*        /\* }else{ /\\* Product of quantitative by...*\\/ *\/ */
+ /*        /\*   if(Dummy[Tvard[k][2]]==0){  /\\* quant by dummy *\\/ *\/ */
+ /*        /\*     /\\* cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][2]][codtabm(ij,TnsdVar[Tvard[k][2]])] * Tqinvresult[nres][Tvard[k][1]]; *\\/ *\/ */
+ /*        /\*     cov[2+nagesqr+k1]=Tqresult[nres][Tinvresult[nres][Tvardk[k1][1]]] * Tresult[nres][Tinvresult[nres][Tvardk[k1][2]]]  ; *\/ */
+ /*        /\*   }else{ /\\* Product of two quant *\\/ *\/ */
+ /*        /\*     /\\* cov[2+nagesqr+Tprod[k]]=Tqinvresult[nres][Tvard[k][1]]*  Tqinvresult[nres][Tvard[k][2]]; *\\/ *\/ */
+ /*        /\*     cov[2+nagesqr+k1]=Tqresult[nres][Tinvresult[nres][Tvardk[k1][1]]] * Tqresult[nres][Tinvresult[nres][Tvardk[k1][2]]]  ; *\/ */
+ /*        /\*   } *\/ */
+ /*        /\* }/\\*end of products quantitative *\\/ *\/ */
+ /*      }/\*end of products *\/ */
+       /* } /\* End of loop on model equation *\/ */
        /* for (k=1; k<=cptcovn;k++)  */
        /*        cov[2+nagesqr+k]=nbcode[Tvar[k]][codtabm(ij,k)]; */
        /* for (k=1; k<=cptcovage;k++) /\* Should start at cptcovn+1 *\/ */
- Line 3516  double ***hpxij(double ***po, int nhstep
+ Line 5430  double ***hpxij(double ***po, int nhstep
  /* double ***hbxij(double ***po, int nhstepm, double age, int hstepm, double *x, double ***prevacurrent, int nlstate, int stepm, double **oldm, double **savm, double **dnewm, double **doldm, double **dsavm, int ij ) */
  double ***hbxij(double ***po, int nhstepm, double age, int hstepm, double *x, double ***prevacurrent, int nlstate, int stepm, int ij, int nres )
  {
-   /* For a combination of dummy covariate ij, computes the transition matrix starting at age 'age' over
+   /* For dummy covariates given in each resultline (for historical, computes the corresponding combination ij),
+      computes the transition matrix starting at age 'age' over
       'nhstepm*hstepm*stepm' months (i.e. until
       age (in years)  age+nhstepm*hstepm*stepm/12) by multiplying
       nhstepm*hstepm matrices.
- Line 3528  double ***hbxij(double ***po, int nhstep
+ Line 5443  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;
+   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 3554  double ***hbxij(double ***po, int nhstep
+ Line 5469  double ***hbxij(double ***po, int nhstep
          /* Debug */
        /* printf("hBxij age=%lf, agexact=%lf\n", age, agexact); */
        cov[2]=agexact;
-       if(nagesqr==1)
+       if(nagesqr==1){
          cov[3]= agexact*agexact;
-       for (k=1; k<=nsd;k++){ /* For single dummy covariates only *//* cptcovn error */
+       }
-       /*        cov[2+nagesqr+k]=nbcode[Tvar[k]][codtabm(ij,k)]; */
+       /** New code */
-       /* /\* cov[2+nagesqr+k]=nbcode[Tvar[k]][codtabm(ij,Tvar[k])]; *\/ */
+       for(k1=1;k1<=cptcovt;k1++){ /* loop on model equation (including products) */
-         cov[2+nagesqr+TvarsDind[k]]=nbcode[TvarsD[k]][codtabm(ij,k)];/* Bug valgrind */
+         if(Typevar[k1]==1 || Typevar[k1]==3){ /* A product with age */
-         /* printf("hbxij Dummy agexact=%.0f combi=%d k=%d TvarsD[%d]=V%d TvarsDind[%d]=%d nbcode=%d cov[%d]=%lf codtabm(%d,Tvar[%d])=%d \n",agexact,ij,k, k, TvarsD[k],k,TvarsDind[k],nbcode[TvarsD[k]][codtabm(ij,k)],2+nagesqr+TvarsDind[k],cov[2+nagesqr+TvarsDind[k]], ij, k, codtabm(ij,k)); */
+           cov[2+nagesqr+k1]=precov[nres][k1]*cov[2];
-       }
-       for (k=1; k<=nsq;k++) { /* For single varying covariates only */
-         /* Here comes the value of quantitative after renumbering k with single quantitative covariates */
-         cov[2+nagesqr+TvarsQind[k]]=Tqresult[nres][k];
-         /* printf("hPxij Quantitative k=%d  TvarsQind[%d]=%d, TvarsQ[%d]=V%d,Tqresult[%d][%d]=%f\n",k,k,TvarsQind[k],k,TvarsQ[k],nres,k,Tqresult[nres][k]); */
-       }
-       for (k=1; k<=cptcovage;k++){ /* Should start at cptcovn+1 *//* For product with age */
-         /* if(Dummy[Tvar[Tage[k]]]== 2){ /\* dummy with age error!!!*\/ */
-         if(Dummy[Tage[k]]== 2){ /* dummy with age */
-           cov[2+nagesqr+Tage[k]]=nbcode[Tvar[Tage[k]]][codtabm(ij,k)]*cov[2];
-         } else if(Dummy[Tage[k]]== 3){ /* quantitative with age */
-           cov[2+nagesqr+Tage[k]]=Tqresult[nres][k];
-         }
-         /* printf("hBxij Age combi=%d k=%d  Tage[%d]=V%d Tqresult[%d][%d]=%f\n",ij,k,k,Tage[k],nres,k,Tqresult[nres][k]); */
-       }
-       for (k=1; k<=cptcovprod;k++){ /* Useless because included in cptcovn */
-         cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)]*nbcode[Tvard[k][2]][codtabm(ij,k)];
-         if(Dummy[Tvard[k][1]==0]){
-           if(Dummy[Tvard[k][2]==0]){
-             cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)] * nbcode[Tvard[k][2]][codtabm(ij,k)];
-           }else{
-             cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)] * Tqresult[nres][k];
-           }
          }else{
-           if(Dummy[Tvard[k][2]==0]){
+           cov[2+nagesqr+k1]=precov[nres][k1];
-             cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][2]][codtabm(ij,k)] * Tqinvresult[nres][Tvard[k][1]];
-           }else{
-             cov[2+nagesqr+Tprod[k]]=Tqinvresult[nres][Tvard[k][1]]*  Tqinvresult[nres][Tvard[k][2]];
-           }
          }
-       }
+       }/* End of loop on model equation */
-       /*printf("hxi cptcov=%d cptcode=%d\n",cptcov,cptcode);*/
+       /** End of new code */
-       /*printf("h=%d d=%d age=%f cov=%f\n",h,d,age,cov[2]);*/
+   /** This was old code */
+       /* for (k=1; k<=nsd;k++){ /\* For single dummy covariates only *\//\* cptcovn error *\/ */
+       /* /\*    cov[2+nagesqr+k]=nbcode[Tvar[k]][codtabm(ij,k)]; *\/ */
+       /* /\* /\\* cov[2+nagesqr+k]=nbcode[Tvar[k]][codtabm(ij,Tvar[k])]; *\\/ *\/ */
+       /*        cov[2+nagesqr+TvarsDind[k]]=nbcode[TvarsD[k]][codtabm(ij,TvarsD[k])];/\* Bug valgrind *\/ */
+       /*   /\* printf("hbxij Dummy agexact=%.0f combi=%d k=%d TvarsD[%d]=V%d TvarsDind[%d]=%d nbcode=%d cov[%d]=%lf codtabm(%d,Tvar[%d])=%d \n",agexact,ij,k, k, TvarsD[k],k,TvarsDind[k],nbcode[TvarsD[k]][codtabm(ij,k)],2+nagesqr+TvarsDind[k],cov[2+nagesqr+TvarsDind[k]], ij, k, codtabm(ij,k)); *\/ */
+       /* } */
+       /* for (k=1; k<=nsq;k++) { /\* For single varying covariates only *\/ */
+       /*        /\* Here comes the value of quantitative after renumbering k with single quantitative covariates *\/ */
+       /*        cov[2+nagesqr+TvarsQind[k]]=Tqresult[nres][k];  */
+       /*        /\* printf("hPxij Quantitative k=%d  TvarsQind[%d]=%d, TvarsQ[%d]=V%d,Tqresult[%d][%d]=%f\n",k,k,TvarsQind[k],k,TvarsQ[k],nres,k,Tqresult[nres][k]); *\/ */
+       /* } */
+       /* for (k=1; k<=cptcovage;k++){ /\* Should start at cptcovn+1 *\//\* For product with age *\/ */
+       /*        /\* if(Dummy[Tvar[Tage[k]]]== 2){ /\\* dummy with age error!!!*\\/ *\/ */
+       /*        if(Dummy[Tage[k]]== 2){ /\* dummy with age *\/ */
+       /*          cov[2+nagesqr+Tage[k]]=nbcode[Tvar[Tage[k]]][codtabm(ij,Tvar[Tage[k]])]*cov[2]; */
+       /*        } else if(Dummy[Tage[k]]== 3){ /\* quantitative with age *\/ */
+       /*          cov[2+nagesqr+Tage[k]]=Tqresult[nres][k];  */
+       /*        } */
+       /*        /\* printf("hBxij Age combi=%d k=%d  Tage[%d]=V%d Tqresult[%d][%d]=%f\n",ij,k,k,Tage[k],nres,k,Tqresult[nres][k]); *\/ */
+       /* } */
+       /* for (k=1; k<=cptcovprod;k++){ /\* Useless because included in cptcovn *\/ */
+       /*        cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,Tvard[k][1])]*nbcode[Tvard[k][2]][codtabm(ij,Tvard[k][2])]; */
+       /*        if(Dummy[Tvard[k][1]]==0){ */
+       /*          if(Dummy[Tvard[k][2]]==0){ */
+       /*            cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,Tvard[k][1])] * nbcode[Tvard[k][2]][codtabm(ij,Tvard[k][1])]; */
+       /*          }else{ */
+       /*            cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,Tvard[k][1])] * Tqresult[nres][k]; */
+       /*          } */
+       /*        }else{ */
+       /*          if(Dummy[Tvard[k][2]]==0){ */
+       /*            cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][2]][codtabm(ij,Tvard[k][2])] * Tqinvresult[nres][Tvard[k][1]]; */
+       /*          }else{ */
+       /*            cov[2+nagesqr+Tprod[k]]=Tqinvresult[nres][Tvard[k][1]]*  Tqinvresult[nres][Tvard[k][2]]; */
+       /*          } */
+       /*        } */
+       /* }                       */
+       /* /\*printf("hxi cptcov=%d cptcode=%d\n",cptcov,cptcode);*\/ */
+       /* /\*printf("h=%d d=%d age=%f cov=%f\n",h,d,age,cov[2]);*\/ */
+ /** End of old code */
        /* Careful transposed matrix */
        /* age is in cov[2], prevacurrent at beginning of transition. */
        /* out=matprod2(newm, bmij(pmmij,cov,ncovmodel,x,nlstate,prevacurrent, dnewm, doldm, dsavm,ij),\ */
- Line 3654  double ***hbxij(double ***po, int nhstep
+ Line 5581  double ***hbxij(double ***po, int nhstep
  /*************** log-likelihood *************/
  double func( double *x)
  {
-   int i, ii, j, k, mi, d, kk;
+   int i, ii, j, k, mi, d, kk, kf=0;
    int ioffset=0;
+   int ipos=0,iposold=0,ncovv=0;
+   double cotvarv, cotvarvold;
    double l, ll[NLSTATEMAX+1], cov[NCOVMAX+1];
    double **out;
    double lli; /* Individual log likelihood */
    int s1, s2;
    int iv=0, iqv=0, itv=0, iqtv=0 ; /* Index of varying covariate, fixed quantitative cov, time varying covariate, quantitative time varying covariate */
    double bbh, survp;
-   long ipmx;
    double agexact;
+   double agebegin, ageend;
    /*extern weight */
    /* We are differentiating ll according to initial status */
    /*  for (i=1;i<=npar;i++) printf("%f ", x[i]);*/
- Line 3686  double func( double *x)
+ Line 5617  double func( double *x)
        */
        ioffset=2+nagesqr ;
     /* Fixed */
-       for (k=1; k<=ncovf;k++){ /* 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 */
          /* TvarFind;  TvarFind[1]=6,  TvarFind[2]=7, TvarFind[3]=9 *//* Inverse V2(6) is first fixed (single or prod)  */
-         cov[ioffset+TvarFind[k]]=covar[Tvar[TvarFind[k]]][i];/* V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1, only V1 is fixed (TvarFind[1]=6)*/
+         cov[ioffset+TvarFind[kf]]=covar[Tvar[TvarFind[kf]]][i];/* V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1, only V1 is fixed (TvarFind[1]=6)*/
          /* V1*V2 (7)  TvarFind[2]=7, TvarFind[3]=9 */
        }
        /* In model V2+V1*V4+age*V3+V3*V2 Tvar[1] is V2, Tvar[2=V1*V4]
- Line 3702  double func( double *x)
+ Line 5633  double func( double *x)
           mw[mi][i] is real wave of the mi th effectve wave */
        /* Then statuses are computed at each begin and end of an effective wave s1=s[ mw[mi][i] ][i];
           s2=s[mw[mi+1][i]][i];
-          And the iv th varying covariate is the cotvar[mw[mi+1][i]][iv][i]
+          And the iv th varying covariate is the cotvar[mw[mi+1][i]][iv][i] because now is moved after nvocol+nqv
           But if the variable is not in the model TTvar[iv] is the real variable effective in the model:
           meaning that decodemodel should be used cotvar[mw[mi+1][i]][TTvar[iv]][i]
        */
-       for(mi=1; mi<= wav[i]-1; mi++){
+       for(mi=1; mi<= wav[i]-1; mi++){  /* Varying with waves */
-         for(k=1; k <= ncovv ; k++){ /* Varying  covariates in the model (single and product but no age )"V5+V4+V3+V4*V3+V5*age+V1*age+V1" +TvarVind 1,2,3,4(V4*V3)  Tvar[1]@7{5, 4, 3, 6, 5, 1, 1 ; 6 because the created covar is after V5 and is 6, minus 1+1, 3,2,1,4 positions in cotvar*/
+       /* Wave varying (but not age varying) */
-           /* cov[ioffset+TvarVind[k]]=cotvar[mw[mi][i]][Tvar[TvarVind[k]]][i]; but where is the crossproduct? */
+         /* for(k=1; k <= ncovv ; k++){ /\* Varying  covariates in the model (single and product but no age )"V5+V4+V3+V4*V3+V5*age+V1*age+V1" +TvarVind 1,2,3,4(V4*V3)  Tvar[1]@7{5, 4, 3, 6, 5, 1, 1 ; 6 because the created covar is after V5 and is 6, minus 1+1, 3,2,1,4 positions in cotvar*\/ */
-           cov[ioffset+TvarVind[k]]=cotvar[mw[mi][i]][Tvar[TvarVind[k]]-ncovcol-nqv][i];
+         /*   /\* cov[ioffset+TvarVind[k]]=cotvar[mw[mi][i]][Tvar[TvarVind[k]]][i]; but where is the crossproduct? *\/ */
+         /*   cov[ioffset+TvarVind[k]]=cotvar[mw[mi][i]][Tvar[TvarVind[k]]-ncovcol-nqv][i]; */
+         /* } */
+         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(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[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;
          }
+         /* for products of time varying to be done */
          for (ii=1;ii<=nlstate+ndeath;ii++)
            for (j=1;j<=nlstate+ndeath;j++){
              oldm[ii][j]=(ii==j ? 1.0 : 0.0);
              savm[ii][j]=(ii==j ? 1.0 : 0.0);
            }
+         agebegin=agev[mw[mi][i]][i]; /* Age at beginning of effective wave */
+         ageend=agev[mw[mi][i]][i] + (dh[mi][i])*stepm/YEARM; /* Age at end of effective wave and at the end of transition */
          for(d=0; d<dh[mi][i]; d++){
            newm=savm;
            agexact=agev[mw[mi][i]][i]+d*stepm/YEARM;
            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]]-ncovcol-nqv][i]*agexact;
+           /*     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 3806  double func( double *x)
+ Line 5776  double func( double *x)
            /*survp += out[s1][j]; */
            lli= log(survp);
          }
-         else if  (s2==-4) {
+         /* else if  (s2==-4) {  */
-           for (j=3,survp=0. ; j<=nlstate; j++)
+         /*   for (j=3,survp=0. ; j<=nlstate; j++)   */
-             survp += (1.+bbh)*out[s1][j]- bbh*savm[s1][j];
+         /*     survp += (1.+bbh)*out[s1][j]- bbh*savm[s1][j]; */
-           lli= log(survp);
+         /*   lli= log(survp);  */
-         }
+         /* }  */
-         else if  (s2==-5) {
+         /* else if  (s2==-5) {  */
-           for (j=1,survp=0. ; j<=2; j++)
+         /*   for (j=1,survp=0. ; j<=2; j++)   */
-             survp += (1.+bbh)*out[s1][j]- bbh*savm[s1][j];
+         /*     survp += (1.+bbh)*out[s1][j]- bbh*savm[s1][j]; */
-           lli= log(survp);
+         /*   lli= log(survp);  */
-         }
+         /* }  */
          else{
            lli= log((1.+bbh)*out[s1][s2]- bbh*savm[s1][s2]); /* linear interpolation */
            /*  lli= (savm[s1][s2]>(double)1.e-8 ?log((1.+bbh)*out[s1][s2]- bbh*(savm[s1][s2])):log((1.+bbh)*out[s1][s2]));*/ /* linear interpolation */
          }
          /*lli=(1.+bbh)*log(out[s1][s2])- bbh*log(savm[s1][s2]);*/
          /*if(lli ==000.0)*/
-         /*printf("bbh= %f lli=%f savm=%f out=%f %d\n",bbh,lli,savm[s1][s2], out[s[mw[mi][i]][i]][s[mw[mi+1][i]][i]],i); */
+         /* printf("num[i], i=%d, bbh= %f lli=%f savm=%f out=%f %d\n",bbh,lli,savm[s1][s2], out[s[mw[mi][i]][i]][s[mw[mi+1][i]][i]],i); */
          ipmx +=1;
          sw += weight[i];
          ll[s[mw[mi][i]][i]] += 2*weight[i]*lli;
- Line 3839  double func( double *x)
+ Line 5809  double func( double *x)
          cov[ioffset+TvarFind[k]]=covar[Tvar[TvarFind[k]]][i];
        for(mi=1; mi<= wav[i]-1; mi++){
          for(k=1; k <= ncovv ; k++){
-           cov[ioffset+TvarVind[k]]=cotvar[mw[mi][i]][Tvar[TvarVind[k]]-ncovcol-nqv][i];
+           cov[ioffset+TvarVind[k]]=cotvar[mw[mi][i]][Tvar[TvarVind[k]]][i]; /* because cotvar starts now at first ncovcol+nqv+ (1 to nqtv) */
          }
          for (ii=1;ii<=nlstate+ndeath;ii++)
            for (j=1;j<=nlstate+ndeath;j++){
- Line 3886  double func( double *x)
+ Line 5856  double func( double *x)
            if(nagesqr==1)
              cov[3]= agexact*agexact;
            for (kk=1; kk<=cptcovage;kk++) {
-             cov[Tage[kk]+2+nagesqr]=covar[Tvar[Tage[kk]]][i]*agexact;
+             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 */
+             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) */
            }
            out=matprod2(newm,oldm,1,nlstate+ndeath,1,nlstate+ndeath,
 ,nlstate+ndeath,pmij(pmmij,cov,ncovmodel,x,nlstate));
- Line 3942  double func( double *x)
+ Line 5915  double func( double *x)
          ipmx +=1;
          sw += weight[i];
          ll[s[mw[mi][i]][i]] += 2*weight[i]*lli;
- /*      printf("i=%6d s1=%1d s2=%1d mi=%1d mw=%1d dh=%3d prob=%10.6f w=%6.4f out=%10.6f sav=%10.6f\n",i,s1,s2,mi,mw[mi][i],dh[mi][i],exp(lli),weight[i],out[s1][s2],savm[s1][s2]); */
+         /* printf("num[i]=%09ld, i=%6d s1=%1d s2=%1d mi=%1d mw=%1d dh=%3d prob=%10.6f w=%6.4f out=%10.6f sav=%10.6f\n",num[i],i,s1,s2,mi,mw[mi][i],dh[mi][i],exp(lli),weight[i],(s2==-1? -1: out[s1][s2]),(s2==-1? -1: savm[s1][s2])); */
        } /* end of wave */
      } /* end of individual */
    }else{  /* ml=5 no inter-extrapolation no jackson =0.8a */
- Line 3961  double func( double *x)
+ Line 5934  double func( double *x)
            if(nagesqr==1)
              cov[3]= agexact*agexact;
            for (kk=1; kk<=cptcovage;kk++) {
-             cov[Tage[kk]+2+nagesqr]=covar[Tvar[Tage[kk]]][i]*agexact;
+             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 */
+             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) */
            }
            out=matprod2(newm,oldm,1,nlstate+ndeath,1,nlstate+ndeath,
- Line 3990  double func( double *x)
+ Line 5966  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;
+   int i, ii, j, k, mi, d, kv=0, kf=0;
    int ioffset=0;
+   int ipos=0,iposold=0,ncovv=0;
+   double cotvarv, cotvarvold;
    double l, ll[NLSTATEMAX+1], cov[NCOVMAX+1];
    double **out;
    double lli; /* Individual log likelihood */
- Line 4013  double funcone( double *x)
+ Line 5992  double funcone( double *x)
    for(k=1; k<=nlstate; k++) ll[k]=0.;
    ioffset=0;
    for (i=1,ipmx=0, sw=0.; i<=imx; i++){
+     /* Computes the values of the ncovmodel covariates of the model
+        depending if the covariates are fixed or varying (age dependent) and stores them in cov[]
+        Then computes with function pmij which return a matrix p[i][j] giving the elementary probability
+        to be observed in j being in i according to the model.
+     */
      /* ioffset=2+nagesqr+cptcovage; */
      ioffset=2+nagesqr;
      /* 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 (k=1; k<=ncovf;k++){ /* 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 */
-       cov[ioffset+TvarFind[k]]=covar[Tvar[TvarFind[k]]][i];/* V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1, only V1 is fixed (k=6)*/
+       /* 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]); */
+       cov[ioffset+TvarFind[kf]]=covar[Tvar[TvarFind[kf]]][i];/* V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1, only V1 is fixed (k=6)*/
  /*    cov[ioffset+TvarFind[1]]=covar[Tvar[TvarFind[1]]][i];  */
  /*    cov[2+6]=covar[Tvar[6]][i];  */
  /*    cov[2+6]=covar[2][i]; V2  */
- Line 4030  double funcone( double *x)
+ Line 6017  double funcone( double *x)
  /*    cov[2+9]=covar[Tvar[9]][i];  */
  /*    cov[2+9]=covar[1][i]; V1  */
      }
+       /* In model V2+V1*V4+age*V3+V3*V2 Tvar[1] is V2, Tvar[2=V1*V4]
+          is 5, Tvar[3=age*V3] should not be computed because of age Tvar[4=V3*V2]=6
+          has been calculated etc */
+       /* For an individual i, wav[i] gives the number of effective waves */
+       /* We compute the contribution to Likelihood of each effective transition
+          mw[mi][i] is real wave of the mi th effectve wave */
+       /* Then statuses are computed at each begin and end of an effective wave s1=s[ mw[mi][i] ][i];
+          s2=s[mw[mi+1][i]][i];
+          And the iv th varying covariate in the DATA is the cotvar[mw[mi+1][i]][ncovcol+nqv+iv][i]
+       */
+     /* This part may be useless now because everythin should be in covar */
      /* for (k=1; k<=nqfveff;k++){ /\* Simple and product fixed Quantitative covariates without age* products *\/ */
      /*   cov[++ioffset]=coqvar[TvarFQ[k]][i];/\* V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1, only V2 and V1*V2 is fixed (k=6 and 7?)*\/ */
      /* } */
- Line 4039  double funcone( double *x)
+ Line 6037  double funcone( double *x)
      for(mi=1; mi<= wav[i]-1; mi++){  /* Varying with waves */
-     /* Wave varying (but not age varying) */
+       /* Wave varying (but not age varying) *//* V1+V3+age*V1+age*V3+V1*V3 with V4 tv and V5 tvq k= 1 to 5 and extra at V(5+1)=6 for V1*V3 */
-       for(k=1; k <= ncovv ; k++){ /* Varying  covariates (single and product but no age )*/
+       /* for(k=1; k <= ncovv ; k++){ /\* Varying  covariates (single and product but no age )*\/ */
-         /* cov[ioffset+TvarVind[k]]=cotvar[mw[mi][i]][Tvar[TvarVind[k]]][i]; */
+       /*        /\* cov[ioffset+TvarVind[k]]=cotvar[mw[mi][i]][Tvar[TvarVind[k]]][i]; *\/ */
-         cov[ioffset+TvarVind[k]]=cotvar[mw[mi][i]][Tvar[TvarVind[k]]-ncovcol-nqv][i];
+       /*        cov[ioffset+TvarVind[k]]=cotvar[mw[mi][i]][Tvar[TvarVind[k]]-ncovcol-nqv][i]; */
-       }
+       /* } */
-       /* 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 *\/ */
+       /*#  ID           V1     V2          weight               birth   death   1st    s1      V3      V4      V5       2nd  s2 */
-       /* cov[ioffset+iv]=cotvar[mw[mi][i]][iv][i]; */
+       /* model V1+V3+age*V1+age*V3+V1*V3 */
-       /* k=ioffset-2-nagesqr-cptcovage+itv; /\* position in simple model *\/ */
+       /*  Tvar={1, 3, 1, 3, 6}, the 6 comes from the fact that there are already V1, V2, V3, V4, V5 native covariates */
-       /* cov[ioffset+itv]=cotvar[mw[mi][i]][TmodelInvind[itv]][i]; */
+       /*  TvarVV[1]=V3 (first time varying in the model equation, TvarVV[2]=V1 (in V1*V3) TvarVV[3]=3(V3)  */
-       /* 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]); */
+       /* We need the position of the time varying or product in the model */
+       /* TvarVVind={2,5,5}, for V3 at position 2 and then the product V1*V3 is decomposed into V1 and V3 but at same position 5 */
+       /* TvarVV gives the variable name */
+       /* Other example V1 + V3 + V5 + age*V1  + age*V3 + age*V5 + V1*V3  + V3*V5  + V1*V5
+       *      k=         1   2     3     4         5        6        7       8        9
+       *  varying            1     2                                 3       4        5
+       *  ncovv              1     2                                3 4     5 6      7 8
+       * TvarVV[ncovv]      V3     5                                1 3     3 5      1 5
+       * TvarVVind           2     3                                7 7     8 8      9 9
+       * TvarFind[k]     1   0     0     0         0        0        0       0        0
+       */
+       /* Other model ncovcol=5 nqv=0 ntv=3 nqtv=0 nlstate=3
+        * 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? 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 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];  /\* 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;
+         }else{ /* A second product */
+           cotvarv=cotvarv*cotvarvold;
+         }
+         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 *\/ */
+       /*        iv=TvarVDind[itv]; /\* iv, position in the model equation of time varying covariate itv *\/ */
+       /*        /\*         "V1+V3+age*V1+age*V3+V1*V3" with V3 time varying *\/ */
+       /*        /\*           1  2   3      4      5                         *\/ */
+       /*        /\*itv           1                                           *\/ */
+       /*        /\* TvarVInd[1]= 2                                           *\/ */
+       /*        /\* iv= Tvar[Tmodelind[itv]]-ncovcol-nqv;  /\\* Counting the # varying covariate from 1 to ntveff *\\/ *\/ */
+       /*        /\* iv= Tvar[Tmodelind[ioffset-2-nagesqr-cptcovage+itv]]-ncovcol-nqv; *\/ */
+       /*        /\* cov[ioffset+iv]=cotvar[mw[mi][i]][iv][i]; *\/ */
+       /*        /\* k=ioffset-2-nagesqr-cptcovage+itv; /\\* position in simple model *\\/ *\/ */
+       /*        /\* cov[ioffset+iv]=cotvar[mw[mi][i]][TmodelInvind[itv]][i]; *\/ */
+       /*        cov[ioffset+iv]=cotvar[mw[mi][i]][itv][i]; */
+       /*        /\* printf(" i=%d,mi=%d,itv=%d,TmodelInvind[itv]=%d,cotvar[mw[mi][i]][itv][i]=%f\n", i, mi, itv, TvarVDind[itv],cotvar[mw[mi][i]][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]); *\/ */
- Line 4072  double funcone( double *x)
+ Line 6217  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]]-ncovcol-nqv][i]*agexact;
+           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 4087  double funcone( double *x)
+ Line 6250  double funcone( double *x)
          savm=oldm;
          oldm=newm;
        } /* end mult */
+         /*lli=log(out[s[mw[mi][i]][i]][s[mw[mi+1][i]][i]]);*/ /* Original formula */
+         /* But now since version 0.9 we anticipate for bias at large stepm.
+          * If stepm is larger than one month (smallest stepm) and if the exact delay
+          * (in months) between two waves is not a multiple of stepm, we rounded to
+          * the nearest (and in case of equal distance, to the lowest) interval but now
+          * we keep into memory the bias bh[mi][i] and also the previous matrix product
+          * (i.e to dh[mi][i]-1) saved in 'savm'. Then we inter(extra)polate the
+          * probability in order to take into account the bias as a fraction of the way
+                                  * from savm to out if bh is negative or even beyond if bh is positive. bh varies
+                                  * -stepm/2 to stepm/2 .
+                                  * For stepm=1 the results are the same as for previous versions of Imach.
+                                  * For stepm > 1 the results are less biased than in previous versions.
+                                  */
        s1=s[mw[mi][i]][i];
        s2=s[mw[mi+1][i]][i];
        /* if(s2==-1){ */
- Line 4119  double funcone( double *x)
+ Line 6294  double funcone( double *x)
        ipmx +=1;
        sw += weight[i];
        ll[s[mw[mi][i]][i]] += 2*weight[i]*lli;
-       /*printf("i=%6d s1=%1d s2=%1d mi=%1d mw=%1d dh=%3d prob=%10.6f w=%6.4f out=%10.6f sav=%10.6f\n",i,s1,s2,mi,mw[mi][i],dh[mi][i],exp(lli),weight[i],out[s1][s2],savm[s1][s2]); */
+       /* Printing covariates values for each contribution for checking */
+       /* printf("num[i]=%09ld, i=%6d s1=%1d s2=%1d mi=%1d mw=%1d dh=%3d prob=%10.6f w=%6.4f out=%10.6f sav=%10.6f\n",num[i],i,s1,s2,mi,mw[mi][i],dh[mi][i],exp(lli),weight[i],(s2==-1? -1: out[s1][s2]),(s2==-1? -1: savm[s1][s2])); */
        if(globpr){
          fprintf(ficresilk,"%09ld %6.1f %6.1f %6d %2d %2d %2d %2d %3d %15.6f %8.4f %8.3f\
   %11.6f %11.6f %11.6f ", \
                  num[i], agebegin, ageend, i,s1,s2,mi,mw[mi][i],dh[mi][i],exp(lli),weight[i],weight[i]*gipmx/gsw,
 *weight[i]*lli,(s2==-1? -1: out[s1][s2]),(s2==-1? -1: savm[s1][s2]));
+         /*      printf("%09ld %6.1f %6.1f %6d %2d %2d %2d %2d %3d %15.6f %8.4f %8.3f\ */
+         /* %11.6f %11.6f %11.6f ", \ */
+         /*              num[i], agebegin, ageend, i,s1,s2,mi,mw[mi][i],dh[mi][i],exp(lli),weight[i],weight[i]*gipmx/gsw, */
+         /*              2*weight[i]*lli,(s2==-1? -1: out[s1][s2]),(s2==-1? -1: savm[s1][s2])); */
          for(k=1,llt=0.,l=0.; k<=nlstate; k++){
            llt +=ll[k]*gipmx/gsw;
            fprintf(ficresilk," %10.6f",-ll[k]*gipmx/gsw);
+           /* printf(" %10.6f",-ll[k]*gipmx/gsw); */
          }
-         fprintf(ficresilk," %10.6f\n", -llt);
+         fprintf(ficresilk," %10.6f ", -llt);
-       }
+         /* printf(" %10.6f\n", -llt); */
-         } /* end of wave */
+         /* if(debugILK){ /\* debugILK is set by a #d in a comment line *\/ */
- } /* end of individual */
+         /* fprintf(ficresilk,"%09ld ", num[i]); */ /* not necessary */
- for(k=1,l=0.; k<=nlstate; k++) l += ll[k];
+         for (kf=1; kf<=ncovf;kf++){ /* Simple and product fixed covariates without age* products *//* Missing values are set to -1 but should be dropped */
+           fprintf(ficresilk," %g",covar[Tvar[TvarFind[kf]]][i]);
+         }
+         for(ncovv=1, iposold=0; ncovv <= ncovvt ; ncovv++){ /* Varying  covariates (single and product but no age) including individual from products */
+           ipos=TvarVVind[ncovv]; /* TvarVVind={2, 5, 5] gives the position in the model of the ncovv th varying covariate*/
+           if(ipos!=iposold){ /* Not a product or first of a product */
+             fprintf(ficresilk," %g",cov[ioffset+ipos]);
+             /* printf(" %g",cov[ioffset+ipos]); */
+           }else{
+             fprintf(ficresilk,"*");
+             /* printf("*"); */
+           }
+           iposold=ipos;
+         }
+         /* for (kk=1; kk<=cptcovage;kk++) { */
+         /*   if(!FixedV[Tvar[Tage[kk]]]){ */
+         /*     fprintf(ficresilk," %g*age",covar[Tvar[Tage[kk]]][i]); */
+         /*     /\* printf(" %g*age",covar[Tvar[Tage[kk]]][i]); *\/ */
+         /*   }else{ */
+         /*     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) *\\/  *\/ */
+         /*   } */
+         /* } */
+         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 *\/ */
+         fprintf(ficresilk,"\n");
+       } /* End if globpr */
+     } /* end of wave */
+   } /* end of individual */
+   for(k=1,l=0.; k<=nlstate; k++) l += ll[k];
  /* printf("l1=%f l2=%f ",ll[1],ll[2]); */
- l= l*ipmx/sw; /* To get the same order of magnitude as if weight=1 for every body */
+   l= l*ipmx/sw; /* To get the same order of magnitude as if weight=1 for every body */
- if(globpr==0){ /* First time we count the contributions and weights */
+   if(globpr==0){ /* First time we count the contributions and weights */
-         gipmx=ipmx;
+     gipmx=ipmx;
-         gsw=sw;
+     gsw=sw;
- }
+   }
- return -l;
+   return -l;
  }
- Line 4151  void likelione(FILE *ficres,double p[],
+ Line 6386  void likelione(FILE *ficres,double p[],
       the selection of individuals/waves and
       to check the exact contribution to the likelihood.
       Plotting could be done.
-    */
+   */
-   int k;
+   void pstamp(FILE *ficres);
+   int k, kf, kk, kvar, ncovv, iposold, ipos;
    if(*globpri !=0){ /* Just counts and sums, no printings */
      strcpy(fileresilk,"ILK_");
- Line 4161  void likelione(FILE *ficres,double p[],
+ Line 6397  void likelione(FILE *ficres,double p[],
        printf("Problem with resultfile: %s\n", fileresilk);
        fprintf(ficlog,"Problem with resultfile: %s\n", fileresilk);
      }
+     pstamp(ficresilk);fprintf(ficresilk,"# model=1+age+%s\n",model);
      fprintf(ficresilk, "#individual(line's_record) count ageb ageend s1 s2 wave# effective_wave# number_of_matrices_product pij weight weight/gpw -2ln(pij)*weight 0pij_x 0pij_(x-stepm) cumulating_loglikeli_by_health_state(reweighted=-2ll*weightXnumber_of_contribs/sum_of_weights) and_total\n");
      fprintf(ficresilk, "#num_i ageb agend i s1 s2 mi mw dh likeli weight %%weight 2wlli out sav ");
      /*  i,s1,s2,mi,mw[mi][i],dh[mi][i],exp(lli),weight[i],2*weight[i]*lli,out[s1][s2],savm[s1][s2]); */
      for(k=1; k<=nlstate; k++)
        fprintf(ficresilk," -2*gipw/gsw*weight*ll[%d]++",k);
-     fprintf(ficresilk," -2*gipw/gsw*weight*ll(total)\n");
+     fprintf(ficresilk," -2*gipw/gsw*weight*ll(total) ");
-   }
+     /* if(debugILK){ /\* debugILK is set by a #d in a comment line *\/ */
+       for(kf=1;kf <= ncovf; kf++){
+         fprintf(ficresilk,"V%d",Tvar[TvarFind[kf]]);
+         /* printf("V%d",Tvar[TvarFind[kf]]); */
+       }
+       for(ncovv=1, iposold=0; ncovv <= ncovvt ; ncovv++){
+         ipos=TvarVVind[ncovv]; /* TvarVVind={2, 5, 5] gives the position in the model of the ncovv th varying covariate */
+         if(ipos!=iposold){ /* Not a product or first of a product */
+           /* printf(" %d",ipos); */
+           fprintf(ficresilk," V%d",TvarVV[ncovv]);
+         }else{
+           /* printf("*"); */
+           fprintf(ficresilk,"*");
+         }
+         iposold=ipos;
+       }
+       for (kk=1; kk<=cptcovage;kk++) {
+         if(!FixedV[Tvar[Tage[kk]]]){
+           /* printf(" %d*age(Fixed)",Tvar[Tage[kk]]); */
+           fprintf(ficresilk," %d*age(Fixed)",Tvar[Tage[kk]]);
+         }else{
+           fprintf(ficresilk," %d*age(Varying)",Tvar[Tage[kk]]);/* because cotvar starts now at first ncovcol+nqv+ (1 to nqtv) */
+           /* printf(" %d*age(Varying)",Tvar[Tage[kk]]);/\* because cotvar starts now at first ncovcol+nqv+ (1 to nqtv) *\/  */
+         }
+       }
+     /* } /\* End if debugILK *\/ */
+     /* printf("\n"); */
+     fprintf(ficresilk,"\n");
+   } /* End glogpri */
    *fretone=(*func)(p);
    if(*globpri !=0){
- Line 4179  void likelione(FILE *ficres,double p[],
+ Line 6445  void likelione(FILE *ficres,double p[],
      fprintf(fichtm," You should at least run with mle >= 1 to get starting values corresponding to the optimized parameters in order to visualize the real contribution of each individual/wave: <a href=\"%s\">%s</a><br>\n",subdirf(fileresilk),subdirf(fileresilk));
      fprintf(fichtm,"\n<br>Equation of the model: <b>model=1+age+%s</b><br>\n",model);
-     for (k=1; k<= nlstate ; k++) {
-       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> \
- <img src=\"%s-p%dj.png\">",k,k,subdirf2(optionfilefiname,"ILK_"),k,subdirf2(optionfilefiname,"ILK_"),k,subdirf2(optionfilefiname,"ILK_"),k);
-     }
      fprintf(fichtm,"<br>- The function drawn is -2Log(L) in Log scale: by state of origin <a href=\"%s-ori.png\">%s-ori.png</a><br> \
- <img src=\"%s-ori.png\">",subdirf2(optionfilefiname,"ILK_"),subdirf2(optionfilefiname,"ILK_"),subdirf2(optionfilefiname,"ILK_"));
+ <img src=\"%s-ori.png\">\n",subdirf2(optionfilefiname,"ILK_"),subdirf2(optionfilefiname,"ILK_"),subdirf2(optionfilefiname,"ILK_"));
      fprintf(fichtm,"<br>- and by state of destination <a href=\"%s-dest.png\">%s-dest.png</a><br> \
- <img src=\"%s-dest.png\">",subdirf2(optionfilefiname,"ILK_"),subdirf2(optionfilefiname,"ILK_"),subdirf2(optionfilefiname,"ILK_"));
+ <img src=\"%s-dest.png\">\n",subdirf2(optionfilefiname,"ILK_"),subdirf2(optionfilefiname,"ILK_"),subdirf2(optionfilefiname,"ILK_"));
+     for (k=1; k<= nlstate ; k++) {
+       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 */
+          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]]);
+          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 */
+         kvar=TvarVV[ncovv]; /*  TvarVV={3, 1, 3} gives the name of each varying covariate */
+         /* printf("DebugILK fichtm ncovv=%d, kvar=TvarVV[ncovv]=V%d, ipos=TvarVVind[ncovv]=%d, Dummy[ipos]=%d, Typevar[ipos]=%d\n", ncovv,kvar,ipos,Dummy[ipos],Typevar[ipos]); */
+         if(ipos!=iposold){ /* Not a product or first of a product */
+           /* fprintf(ficresilk," V%d",TvarVV[ncovv]); */
+           /* printf(" DebugILK fichtm ipos=%d != iposold=%d\n", ipos, iposold); */
+           if(Dummy[ipos]==0 && Typevar[ipos]==0){ /* Only if dummy time varying: Dummy(0, 1=quant singor prod without age,2 dummy*age, 3quant*age) Typevar (0 single, 1=*age,2=Vn*vm)  */
+             fprintf(fichtm,"<br>- Probability p<sub>%dj</sub> by origin %d and destination j with colored time varying dummy 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> \
+ <img src=\"%s-p%dj-%d.png\">",k,k,kvar,kvar,kvar,subdirf2(optionfilefiname,"ILK_"),k,subdirf2(optionfilefiname,"ILK_"),k,subdirf2(optionfilefiname,"ILK_"),k,kvar);
+           } /* End only for dummies time varying (single?) */
+         }else{ /* Useless product */
+           /* printf("*"); */
+           /* fprintf(ficresilk,"*"); */
+         }
+         iposold=ipos;
+       } /* For each time varying covariate */
+     } /* End loop on states */
+ /*     if(debugILK){ */
+ /*       for(kf=1; kf <= ncovf; kf++){ /\* For each simple dummy covariate of the model *\/ */
+ /*      /\* kvar=Tvar[TvarFind[kf]]; *\/ /\* variable *\/ */
+ /*      for (k=1; k<= nlstate ; k++) { */
+ /*        fprintf(fichtm,"<br>- Probability p<sub>%dj</sub> by origin %d and destination j with colored covariate V%. 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> \ */
+ /* <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]]); */
+ /*      } */
+ /*       } */
+ /*       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 *\/ */
+ /*      kvar=TvarVV[ncovv]; /\*  TvarVV={3, 1, 3} gives the name of each varying covariate *\/ */
+ /*      /\* printf("DebugILK fichtm ncovv=%d, kvar=TvarVV[ncovv]=V%d, ipos=TvarVVind[ncovv]=%d, Dummy[ipos]=%d, Typevar[ipos]=%d\n", ncovv,kvar,ipos,Dummy[ipos],Typevar[ipos]); *\/ */
+ /*      if(ipos!=iposold){ /\* Not a product or first of a product *\/ */
+ /*        /\* fprintf(ficresilk," V%d",TvarVV[ncovv]); *\/ */
+ /*        /\* printf(" DebugILK fichtm ipos=%d != iposold=%d\n", ipos, iposold); *\/ */
+ /*        if(Dummy[ipos]==0 && Typevar[ipos]==0){ /\* Only if dummy time varying: Dummy(0, 1=quant singor prod without age,2 dummy*age, 3quant*age) Typevar (0 single, 1=*age,2=Vn*vm)  *\/ */
+ /*          for (k=1; k<= nlstate ; k++) { */
+ /*            fprintf(fichtm,"<br>- Probability p<sub>%dj</sub> by origin %d and destination j. 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> \ */
+ /* <img src=\"%s-p%dj-%d.png\">",k,k,kvar,kvar,subdirf2(optionfilefiname,"ILK_"),k,subdirf2(optionfilefiname,"ILK_"),k,subdirf2(optionfilefiname,"ILK_"),k,kvar); */
+ /*          } /\* End state *\/ */
+ /*        } /\* End only for dummies time varying (single?) *\/ */
+ /*      }else{ /\* Useless product *\/ */
+ /*        /\* printf("*"); *\/ */
+ /*        /\* fprintf(ficresilk,"*"); *\/  */
+ /*      } */
+ /*      iposold=ipos; */
+ /*       } /\* For each time varying covariate *\/ */
+ /*     }/\* End debugILK *\/ */
      fflush(fichtm);
-   }
+   }/* End globpri */
    return;
  }
- Line 4197  void likelione(FILE *ficres,double p[],
+ Line 6516  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 4282  void mlikeli(FILE *ficres,double p[], in
+ Line 6602  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); */
+   ffmin = praxis(ftol,macheps, h0, npar, prin, p, func);
+ printf("End Praxis\n");
  #endif  /* FLATSUP */
  #ifdef LINMINORIGINAL
- Line 4544  double hessij( double x[], double **hess
+ Line 6880  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 4730  void  freqsummary(char fileres[], double
+ Line 7067  void  freqsummary(char fileres[], double
                    int *Tvaraff, int *invalidvarcomb, int **nbcode, int *ncodemax,double **mint,double **anint, char strstart[], \
                    int firstpass,  int lastpass, int stepm, int weightopt, char model[])
  {  /* Some frequencies as well as proposing some starting values */
+   /* Frequencies of any combination of dummy covariate used in the model equation */
    int i, m, jk, j1, bool, z1,j, nj, nl, k, iv, jj=0, s1=1, s2=1;
    int iind=0, iage=0;
    int mi; /* Effective wave */
- Line 4798  Title=%s <br>Datafile=%s Firstpass=%d La
+ Line 7135  Title=%s <br>Datafile=%s Firstpass=%d La
    j1=0;
    /* j=ncoveff;  /\* Only fixed dummy covariates *\/ */
-   j=cptcoveff;  /* Only dummy covariates of the model */
+   j=cptcoveff;  /* Only simple dummy covariates used in the model */
+   /* j=cptcovn;  /\* Only dummy covariates of the model *\/ */
    if (cptcovn<1) {j=1;ncodemax[1]=1;}
- Line 4806  Title=%s <br>Datafile=%s Firstpass=%d La
+ Line 7144  Title=%s <br>Datafile=%s Firstpass=%d La
       reference=low_education V1=0,V2=0
       med_educ                V1=1 V2=0,
       high_educ               V1=0 V2=1
-      Then V1=1 and V2=1 is a noisy combination that we want to exclude for the list 2**cptcoveff
+      Then V1=1 and V2=1 is a noisy combination that we want to exclude for the list 2**cptcovn
    */
    dateintsum=0;
    k2cpt=0;
- Line 4843  Title=%s <br>Datafile=%s Firstpass=%d La
+ Line 7181  Title=%s <br>Datafile=%s Firstpass=%d La
      if(nj==1)
        j=0;  /* First pass for the constant */
      else{
-       j=cptcoveff; /* Other passes for the covariate values */
+       j=cptcoveff; /* Other passes for the covariate values number of simple covariates in the model V2+V1 =2 (simple dummy fixed or time varying) */
      }
      first=1;
-     for (j1 = 1; j1 <= (int) pow(2,j); j1++){ /* Loop on all covariates combination of the model, excluding quantitatives, V4=0, V3=0 for example, fixed or varying covariates */
+     for (j1 = 1; j1 <= (int) pow(2,j); j1++){ /* Loop on all dummy covariates combination of the model, ie excluding quantitatives, V4=0, V3=0 for example, fixed or varying covariates */
        posproptt=0.;
-       /*printf("cptcoveff=%d Tvaraff=%d", cptcoveff,Tvaraff[1]);
+       /*printf("cptcovn=%d Tvaraff=%d", cptcovn,Tvaraff[1]);
          scanf("%d", i);*/
        for (i=-5; i<=nlstate+ndeath; i++)
          for (s2=-5; s2<=nlstate+ndeath; s2++)
- Line 4885  Title=%s <br>Datafile=%s Firstpass=%d La
+ Line 7223  Title=%s <br>Datafile=%s Firstpass=%d La
                  /*       /\* sumnew+=cotvar[mw[mi][iind]][z1][iind]; *\/ */
                  /* }else  if(Tvaraff[z1] ==-10){ */
                  /*       /\* sumnew+=coqvar[z1][iind]; *\/ */
-                 /* }else  */
+                 /* }else  */ /* TODO TODO codtabm(j1,z1) or codtabm(j1,Tvaraff[z1]]z1)*/
-                 if (covar[Tvaraff[z1]][iind]!= nbcode[Tvaraff[z1]][codtabm(j1,z1)]){ /* for combination j1 of covariates */
+                 /* if( iind >=imx-3) printf("Searching error iind=%d Tvaraff[z1]=%d covar[Tvaraff[z1]][iind]=%.f TnsdVar[Tvaraff[z1]]=%d, cptcoveff=%d, cptcovs=%d \n",iind, Tvaraff[z1], covar[Tvaraff[z1]][iind],TnsdVar[Tvaraff[z1]],cptcoveff, cptcovs); */
+                 if(Tvaraff[z1]<1 || Tvaraff[z1]>=NCOVMAX)
+                   printf("Error Tvaraff[z1]=%d<1 or >=%d, cptcoveff=%d model=1+age+%s\n",Tvaraff[z1],NCOVMAX, cptcoveff, model);
+                 if (covar[Tvaraff[z1]][iind]!= nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]){ /* for combination j1 of covariates */
                    /* Tests if the value of the covariate z1 for this individual iind responded to combination j1 (V4=1 V3=0) */
                    bool=0; /* bool should be equal to 1 to be selected, one covariate value failed */
-                   /* printf("bool=%d i=%d, z1=%d, Tvaraff[%d]=%d, covar[Tvarff][%d]=%2f, codtabm(%d,%d)=%d, nbcode[Tvaraff][codtabm(%d,%d)=%d, j1=%d\n",
+                   /* printf("bool=%d i=%d, z1=%d, Tvaraff[%d]=%d, covar[Tvarff][%d]=%2f, codtabm(%d,%d)=%d, nbcode[Tvaraff][codtabm(%d,%d)=%d, j1=%d\n", */
-                      bool,i,z1, z1, Tvaraff[z1],i,covar[Tvaraff[z1]][i],j1,z1,codtabm(j1,z1),
+                   /*   bool,i,z1, z1, Tvaraff[z1],i,covar[Tvaraff[z1]][i],j1,z1,codtabm(j1,z1),*/
-                      j1,z1,nbcode[Tvaraff[z1]][codtabm(j1,z1)],j1);*/
+                   /*   j1,z1,nbcode[Tvaraff[z1]][codtabm(j1,z1)],j1);*/
                    /* For j1=7 in V1+V2+V3+V4 = 0 1 1 0 and codtabm(7,3)=1 and nbcde[3][?]=1*/
                  } /* Onlyf fixed */
                } /* end z1 */
-             } /* cptcovn > 0 */
+             } /* cptcoveff > 0 */
            } /* end any */
          }/* end j==0 */
          if (bool==1){ /* We selected an individual iind satisfying combination j1 (V4=1 V3=0) or all fixed covariates */
- Line 4906  Title=%s <br>Datafile=%s Firstpass=%d La
+ Line 7247  Title=%s <br>Datafile=%s Firstpass=%d La
                if(anyvaryingduminmodel==1){ /* Some are varying covariates */
                  for (z1=1; z1<=cptcoveff; z1++) {
                    if( Fixed[Tmodelind[z1]]==1){
-                     iv= Tvar[Tmodelind[z1]]-ncovcol-nqv;
+                     /* iv= Tvar[Tmodelind[z1]]-ncovcol-nqv; /\* Good *\/ */
-                     if (cotvar[m][iv][iind]!= nbcode[Tvaraff[z1]][codtabm(j1,z1)]) /* iv=1 to ntv, right modality. If covariate's
+                     iv= Tvar[Tmodelind[z1]]; /* Good *//* because cotvar starts now at first at ncovcol+nqv+ntv */
+                     if (cotvar[m][iv][iind]!= nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]) /* iv=1 to ntv, right modality. If covariate's
                                                                                        value is -1, we don't select. It differs from the
                                                                                        constant and age model which counts them. */
                        bool=0; /* not selected */
                    }else if( Fixed[Tmodelind[z1]]== 0) { /* fixed */
-                     if (covar[Tvaraff[z1]][iind]!= nbcode[Tvaraff[z1]][codtabm(j1,z1)]) {
+                     /* i1=Tvaraff[z1]; */
+                     /* i2=TnsdVar[i1]; */
+                     /* i3=nbcode[i1][i2]; */
+                     /* i4=covar[i1][iind]; */
+                     /* if(i4 != i3){ */
+                     if (covar[Tvaraff[z1]][iind]!= nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]) { /* Bug valgrind */
                        bool=0;
                      }
                    }
- Line 4940  Title=%s <br>Datafile=%s Firstpass=%d La
+ Line 7287  Title=%s <br>Datafile=%s Firstpass=%d La
                    freq[s[m][iind]][s[m+1][iind]][(int)agev[m][iind]] += weight[iind]; /* At age of beginning of transition, where status is known */
                    for (z1=1; z1<= nqfveff; z1++) { /* Quantitative variables, calculating mean on known values only */
                      if(!isnan(covar[ncovcol+z1][iind])){
-                         idq[z1]=idq[z1]+weight[iind];
+                       idq[z1]=idq[z1]+weight[iind];
-                         meanq[z1]+=covar[ncovcol+z1][iind]*weight[iind];  /* Computes mean of quantitative with selected filter */
+                       meanq[z1]+=covar[ncovcol+z1][iind]*weight[iind];  /* Computes mean of quantitative with selected filter */
-                         /* stdq[z1]+=covar[ncovcol+z1][iind]*covar[ncovcol+z1][iind]*weight[iind]*weight[iind]; *//*error*/
+                       /* stdq[z1]+=covar[ncovcol+z1][iind]*covar[ncovcol+z1][iind]*weight[iind]*weight[iind]; *//*error*/
-                         stdq[z1]+=covar[ncovcol+z1][iind]*covar[ncovcol+z1][iind]*weight[iind]; /* *weight[iind];*/  /* Computes mean of quantitative with selected filter */
+                       stdq[z1]+=covar[ncovcol+z1][iind]*covar[ncovcol+z1][iind]*weight[iind]; /* *weight[iind];*/  /* Computes mean of quantitative with selected filter */
                      }
                    }
                    /* if((int)agev[m][iind] == 55) */
- Line 4984  Title=%s <br>Datafile=%s Firstpass=%d La
+ Line 7331  Title=%s <br>Datafile=%s Firstpass=%d La
          fprintf(ficlog, "\n#********** Variable ");
          for (z1=1; z1<=cptcoveff; z1++){
            if(!FixedV[Tvaraff[z1]]){
-             printf( "V%d(fixed)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
+             printf( "V%d(fixed)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]);
-             fprintf(ficresp, "V%d(fixed)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
+             fprintf(ficresp, "V%d(fixed)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]);
-             fprintf(ficresphtm, "V%d(fixed)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
+             fprintf(ficresphtm, "V%d(fixed)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]);
-             fprintf(ficresphtmfr, "V%d(fixed)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
+             fprintf(ficresphtmfr, "V%d(fixed)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]);
-             fprintf(ficlog, "V%d(fixed)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
+             fprintf(ficlog, "V%d(fixed)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]);
            }else{
-             printf( "V%d(varying)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
+             printf( "V%d(varying)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]);
-             fprintf(ficresp, "V%d(varying)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
+             fprintf(ficresp, "V%d(varying)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]);
-             fprintf(ficresphtm, "V%d(varying)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
+             fprintf(ficresphtm, "V%d(varying)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]);
-             fprintf(ficresphtmfr, "V%d(varying)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
+             fprintf(ficresphtmfr, "V%d(varying)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]);
-             fprintf(ficlog, "V%d(varying)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
+             fprintf(ficlog, "V%d(varying)=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]);
            }
          }
          printf( "**********\n#");
- Line 5030  Title=%s <br>Datafile=%s Firstpass=%d La
+ Line 7377  Title=%s <br>Datafile=%s Firstpass=%d La
        fprintf(ficresphtm,"<table style=\"text-align:center; border: 1px solid\">");
        if((cptcoveff==0 && nj==1)|| nj==2 ) /* no covariate and first pass */
          fprintf(ficresp, " Age");
-       if(nj==2) for (z1=1; z1<=cptcoveff; z1++) fprintf(ficresp, " V%d=%d",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
+       if(nj==2) for (z1=1; z1<=cptcoveff; z1++) {
+           printf(" V%d=%d, z1=%d, Tvaraff[z1]=%d, j1=%d, TnsdVar[Tvaraff[%d]]=%d |",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])], z1, Tvaraff[z1], j1,z1,TnsdVar[Tvaraff[z1]]);
+           fprintf(ficresp, " V%d=%d",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]);
+         }
        for(i=1; i<=nlstate;i++) {
          if((cptcoveff==0 && nj==1)|| nj==2 ) fprintf(ficresp," Prev(%d)  N(%d)  N  ",i,i);
          fprintf(ficresphtm, "<th>Age</th><th>Prev(%d)</th><th>N(%d)</th><th>N</th>",i,i);
- Line 5110  Title=%s <br>Datafile=%s Firstpass=%d La
+ Line 7460  Title=%s <br>Datafile=%s Firstpass=%d La
          }else if( nj==2){
            if( iage <= iagemax){
              fprintf(ficresp," %d",iage);
-             for (z1=1; z1<=cptcoveff; z1++) fprintf(ficresp, " %d %d",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
+             for (z1=1; z1<=cptcoveff; z1++) fprintf(ficresp, " %d %d",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]);
            }
          }
          for(s1=1; s1 <=nlstate ; s1++){
- Line 5187  Title=%s <br>Datafile=%s Firstpass=%d La
+ Line 7537  Title=%s <br>Datafile=%s Firstpass=%d La
          printf("#  This combination (%d) is not valid and no result will be produced\n",j1);
          invalidvarcomb[j1]=1;
        }else{
-         fprintf(ficresphtm,"\n <p> This combination (%d) is valid and result will be produced.</p>",j1);
+         fprintf(ficresphtm,"\n <p> This combination (%d) is valid and result will be produced (or no resultline).</p>",j1);
          invalidvarcomb[j1]=0;
        }
        fprintf(ficresphtmfr,"</table>\n");
- Line 5399  void prevalence(double ***probs, double
+ Line 7749  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 5418  void prevalence(double ***probs, double
+ Line 7768  void prevalence(double ***probs, double
    if (cptcovn<1) {j=1;ncodemax[1]=1;}
    first=0;
-   for(j1=1; j1<= (int) pow(2,cptcoveff);j1++){ /* For each combination of covariate */
+   for(j1=1; j1<= (int) pow(2,cptcoveff);j1++){ /* For each combination of simple dummy covariates */
      for (i=1; i<=nlstate; i++)
        for(iage=iagemin-AGEMARGE; iage <= iagemax+4+AGEMARGE; iage++)
          prop[i][iage]=0.0;
- Line 5435  void prevalence(double ***probs, double
+ Line 7785  void prevalence(double ***probs, double
          /* Tvar[Tmodelind[z1]] is the n of Vn; n-ncovcol-nqv is the first time varying covariate or iv */
          for (z1=1; z1<=cptcoveff; z1++){
            if( Fixed[Tmodelind[z1]]==1){
-             iv= Tvar[Tmodelind[z1]]-ncovcol-nqv;
+             iv= Tvar[Tmodelind[z1]];/* because cotvar starts now at first ncovcol+nqv+ (1 to nqtv) */
-             if (cotvar[m][iv][i]!= nbcode[Tvaraff[z1]][codtabm(j1,z1)]) /* iv=1 to ntv, right modality */
+             if (cotvar[m][iv][i]!= nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]) /* iv=1 to ntv, right modality */
                bool=0;
            }else if( Fixed[Tmodelind[z1]]== 0)  /* fixed */
-             if (covar[Tvaraff[z1]][i]!= nbcode[Tvaraff[z1]][codtabm(j1,z1)]) {
+             if (covar[Tvaraff[z1]][i]!= nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]) {
                bool=0;
              }
          }
- Line 5638  void  concatwav(int wav[], int **dh, int
+ Line 7988  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 5675  void  concatwav(int wav[], int **dh, int
+ Line 8025  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 5742  void  concatwav(int wav[], int **dh, int
+ Line 8092  void  concatwav(int wav[], int **dh, int
         nbcode[k][j]=0; /* Valgrind */
     /* Loop on covariates without age and products and no quantitative variable */
-    for (k=1; k<=cptcovt; k++) { /* From model V1 + V2*age + V3 + V3*V4 keeps V1 + V3 = 2 only */
+    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;
-      if(Dummy[k]==0 && Typevar[k] !=1){ /* Dummy covariate and not age product */
+      /* printf("Testing k=%d, cptcovt=%d\n",k, cptcovt); */
+      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;
           modmincovj=0;
           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*/
+            /* printf("Waiting for error tricode Tvar[%d]=%d i=%d (int)(covar[Tvar[k]][i]=%d\n",k,Tvar[k], i, (int)(covar[Tvar[k]][i])); */
             ij=(int)(covar[Tvar[k]][i]);
             /* ij=0 or 1 or -1. Value of the covariate Tvar[j] for individual i
              * If product of Vn*Vm, still boolean *:
- Line 5840  void  concatwav(int wav[], int **dh, int
+ Line 8192  void  concatwav(int wav[], int **dh, int
           break;
         } /* end switch */
       } /* end dummy test */
-      if(Dummy[k]==1 && Typevar[k] !=1){ /* Dummy 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);
+            exit(1);
+          }
           if(isnan(covar[Tvar[k]][i])){
             printf("ERROR, IMaCh doesn't treat fixed quantitative covariate with missing values V%d=., individual %d will be skipped.\n",Tvar[k],i);
             fprintf(ficlog,"ERROR, currently IMaCh doesn't treat covariate with missing values V%d=., individual %d will be skipped.\n",Tvar[k],i);
- Line 5849  void  concatwav(int wav[], int **dh, int
+ Line 8205  void  concatwav(int wav[], int **dh, int
             exit(1);
           }
         }
-      }
+      } /* end Quanti */
     } /* end of loop on model-covariate k. nbcode[Tvark][1]=-1, nbcode[Tvark][1]=0 and nbcode[Tvark][2]=1 sets the value of covariate k*/
     for (k=-1; k< maxncov; k++) Ndum[k]=0;
- Line 5863  void  concatwav(int wav[], int **dh, int
+ Line 8219  void  concatwav(int wav[], int **dh, int
     ij=0;
     /* for (i=0; i<=  maxncov-1; i++) { /\* modmaxcovj is unknown here. Only Ndum[2(V2),3(age*V3), 5(V3*V2) 6(V1*V4) *\/ */
-    for (k=1; k<=  cptcovt; k++) { /* modmaxcovj is unknown here. Only Ndum[2(V2),3(age*V3), 5(V3*V2) 6(V1*V4) */
+    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 */
+      /* modmaxcovj is unknown here. Only Ndum[2(V2),3(age*V3), 5(V3*V2) 6(V1*V4) */
       /*printf("Ndum[%d]=%d\n",i, Ndum[i]);*/
       /* if((Ndum[i]!=0) && (i<=ncovcol)){  /\* Tvar[i] <= ncovmodel ? *\/ */
-      if(Ndum[Tvar[k]]!=0 && Dummy[k] == 0 && Typevar[k]==0){  /* Only Dummy and non empty in the model */
+      if(Ndum[Tvar[k]]!=0 && Dummy[k] == 0 && Typevar[k]==0){  /* Only Dummy simple and non empty in the model */
+        /* Typevar[k] =0 for simple covariate (dummy, quantitative, fixed or varying), 1 for age product, 2 for 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 product not in single variable we don't print results */
         /*printf("diff Ndum[%d]=%d\n",i, Ndum[i]);*/
-        ++ij;/* V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1, */
+        ++ij;/*    V5 + V4 + V3 + V4*V3 + V5*age + V2 +  V1*V2 + V1*age + V1, *//* V5 quanti, V2 quanti, V4, V3, V1 dummies */
+        /* k=       1    2   3     4       5       6      7       8        9  */
+        /* Tvar[k]= 5    4    3    6       5       2      7       1        1  */
+        /* ij            1    2                                            3  */
+        /* Tvaraff[ij]=  4    3                                            1  */
+        /* Tmodelind[ij]=2    3                                            9  */
+        /* TmodelInvind[ij]=2 1                                            1  */
         Tvaraff[ij]=Tvar[k]; /* For printing combination *//* V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1, Tvar {5, 4, 3, 6, 5, 2, 7, 1, 1} Tvaraff={4, 3, 1} V4, V3, V1*/
         Tmodelind[ij]=k; /* Tmodelind: index in model of dummies Tmodelind[1]=2 V4: pos=2; V3: pos=3, V1=9 {2, 3, 9, ?, ?,} */
         TmodelInvind[ij]=Tvar[k]- ncovcol-nqv; /* Inverse TmodelInvind[2=V4]=2 second dummy varying cov (V4)4-1-1 {0, 2, 1, } TmodelInvind[3]=1 */
- Line 5885  void  concatwav(int wav[], int **dh, int
+ Line 8250  void  concatwav(int wav[], int **dh, int
     } /* Tvaraff[1]@5 {3, 4, -20, 0, 0} Very strange */
     /* ij--; */
     /* cptcoveff=ij; /\*Number of total covariates*\/ */
-    *cptcov=ij; /*Number of total real effective covariates: effective
+    *cptcov=ij; /* cptcov= Number of total real effective simple dummies (fixed or time  arying) effective (used as cptcoveff in other functions)
                  * because they can be excluded from the model and real
                  * if in the model but excluded because missing values, but how to get k from ij?*/
     for(j=ij+1; j<= cptcovt; j++){
- Line 5906  void  concatwav(int wav[], int **dh, int
+ Line 8271  void  concatwav(int wav[], int **dh, int
  {
    /* Health expectancies, no variances */
+   /* cij is the combination in the list of combination of dummy covariates */
+   /* strstart is a string of time at start of computing */
    int i, j, nhstepm, hstepm, h, nstepm;
    int nhstepma, nstepma; /* Decreasing with age */
    double age, agelim, hf;
- Line 5974  void  concatwav(int wav[], int **dh, int
+ Line 8341  void  concatwav(int wav[], int **dh, int
      /* If stepm=6 months */
      /* Computed by stepm unit matrices, product of hstepma matrices, stored
         in an array of nhstepma length: nhstepma=10, hstepm=4, stepm=6 months */
+     /* printf("HELLO evsij Entering hpxij age=%d cij=%d hstepm=%d x[1]=%f nres=%d\n",(int) age, cij, hstepm, x[1], nres); */
      hpxij(p3mat,nhstepma,age,hstepm,x,nlstate,stepm,oldm, savm, cij, nres);
      hf=hstepm*stepm/YEARM;  /* Duration of hstepm expressed in year unit. */
- Line 6016  void  concatwav(int wav[], int **dh, int
+ Line 8383  void  concatwav(int wav[], int **dh, int
    /* Covariances of health expectancies eij and of total life expectancies according
       to initial status i, ei. .
    */
+   /* Very time consuming function, but already optimized with precov */
    int i, j, nhstepm, hstepm, h, nstepm, k, cptj, cptj2, i2, j2, ij, ji;
    int nhstepma, nstepma; /* Decreasing with age */
    double age, agelim, hf;
- Line 6226  void  concatwav(int wav[], int **dh, int
+ Line 8594  void  concatwav(int wav[], int **dh, int
  /************ Variance ******************/
   void varevsij(char optionfilefiname[], double ***vareij, double **matcov, double x[], double delti[], int nlstate, int stepm, double bage, double fage, double **oldm, double **savm, double **prlim, double ftolpl, int *ncvyearp, int ij, int estepm, int cptcov, int cptcod, int popbased, int mobilav, char strstart[], int nres)
   {
-    /** Variance of health expectancies
+    /** Computes the matrix of variance covariance of health expectancies e.j= sum_i w_i e_ij where w_i depends of popbased,
+     * either cross-sectional or implied.
+     * return vareij[i][j][(int)age]=cov(e.i,e.j)=sum_h sum_k trgrad(h_p.i) V(theta) grad(k_p.k) Equation 20
      *  double **prevalim(double **prlim, int nlstate, double *xp, double age, double **oldm, double ** savm,double ftolpl);
      * double **newm;
      * int movingaverage(double ***probs, double bage,double fage, double ***mobaverage, int mobilav)
- Line 6243  void  concatwav(int wav[], int **dh, int
+ Line 8613  void  concatwav(int wav[], int **dh, int
     double ***gradg, ***trgradg; /**< for var eij */
     double **gradgp, **trgradgp; /**< for var p point j */
     double *gpp, *gmp; /**< for var p point j */
-    double **varppt; /**< for var p point j nlstate to nlstate+ndeath */
+    double **varppt; /**< for var p.3 p.death nlstate+1 to nlstate+ndeath */
     double ***p3mat;
     double age,agelim, hf;
     /* double ***mobaverage; */
- Line 6284  void  concatwav(int wav[], int **dh, int
+ Line 8654  void  concatwav(int wav[], int **dh, int
     pstamp(ficresprobmorprev);
     fprintf(ficresprobmorprev,"# probabilities of dying before estepm=%d months for people of exact age and weighted probabilities w1*p1j+w2*p2j+... stand dev in()\n",estepm);
     fprintf(ficresprobmorprev,"# Selected quantitative variables and dummies");
-    for (j=1; j<= nsq; j++){ /* For each selected (single) quantitative value */
-      fprintf(ficresprobmorprev," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+    /* We use TinvDoQresult[nres][resultmodel[nres][j] we sort according to the equation model and the resultline: it is a choice */
+    /* for (j=1; j<= nsq; j++){ /\* For each selected (single) quantitative value *\/ /\* To be done*\/ */
+    /*   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++)
+    /* for(j=1;j<=cptcoveff;j++)  */
-      fprintf(ficresprobmorprev,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(ij,j)]);
+    /*   fprintf(ficresprobmorprev," V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(ij,TnsdVar[Tvaraff[j]])]); */
     fprintf(ficresprobmorprev,"\n");
     fprintf(ficresprobmorprev,"# Age cov=%-d",ij);
- Line 6305  void  concatwav(int wav[], int **dh, int
+ Line 8681  void  concatwav(int wav[], int **dh, int
     fprintf(fichtm,"\n<li><h4> Computing probabilities of dying over estepm months as a weighted average (i.e global mortality independent of initial healh state)</h4></li>\n");
     fprintf(fichtm,"\n<br>%s  <br>\n",digitp);
-    varppt = matrix(nlstate+1,nlstate+ndeath,nlstate+1,nlstate+ndeath);
+    varppt = matrix(nlstate+1,nlstate+ndeath,nlstate+1,nlstate+ndeath); /* In fact, currently a double */
     pstamp(ficresvij);
     fprintf(ficresvij,"# Variance and covariance of health expectancies e.j \n#  (weighted average of eij where weights are ");
     if(popbased==1)
- Line 6374  void  concatwav(int wav[], int **dh, int
+ Line 8750  void  concatwav(int wav[], int **dh, int
               prlim[i][i]=mobaverage[(int)age][i][ij];
           }
         }
-        /**< Computes the shifted transition matrix \f$ {}{h}_p^{ij}x\f$ at horizon h.
+        /**< Computes the shifted plus (gp) transition matrix \f$ {}{h}_p^{ij}x\f$ at horizon h.
          */
         hpxij(p3mat,nhstepm,age,hstepm,xp,nlstate,stepm,oldm,savm, ij,nres);  /* Returns p3mat[i][j][h] for h=0 to nhstepm */
         /**< And for each alive state j, sums over i \f$ w^i_x {}{h}_p^{ij}x\f$, which are the probability
- Line 6383  void  concatwav(int wav[], int **dh, int
+ Line 8759  void  concatwav(int wav[], int **dh, int
         for(j=1; j<= nlstate; j++){
           for(h=0; h<=nhstepm; h++){
             for(i=1, gp[h][j]=0.;i<=nlstate;i++)
-              gp[h][j] += prlim[i][i]*p3mat[i][j][h];
+              gp[h][j] += prlim[i][i]*p3mat[i][j][h]; /* gp[h][j]= w_i h_pij */
           }
         }
         /* Next for computing shifted+ probability of death (h=1 means
            computed over hstepm matrices product = hstepm*stepm months)
            as a weighted average of prlim(i) * p(i,j) p.3=w1*p13 + w2*p23 .
         */
-        for(j=nlstate+1;j<=nlstate+ndeath;j++){
+        for(j=nlstate+1;j<=nlstate+ndeath;j++){ /* Currently only once for theta plus  p.3(age) Sum_i wi pi3*/
           for(i=1,gpp[j]=0.; i<= nlstate; i++)
             gpp[j] += prlim[i][i]*p3mat[i][j][1];
         }
- Line 6412  void  concatwav(int wav[], int **dh, int
+ Line 8788  void  concatwav(int wav[], int **dh, int
           }
         }
-        hpxij(p3mat,nhstepm,age,hstepm,xp,nlstate,stepm,oldm,savm, ij,nres);
+        hpxij(p3mat,nhstepm,age,hstepm,xp,nlstate,stepm,oldm,savm, ij,nres);  /* Still minus */
-        for(j=1; j<= nlstate; j++){  /* Sum of wi * eij = e.j */
+        for(j=1; j<= nlstate; j++){  /* gm[h][j]= Sum_i of wi * pij =  h_p.j */
           for(h=0; h<=nhstepm; h++){
             for(i=1, gm[h][j]=0.;i<=nlstate;i++)
               gm[h][j] += prlim[i][i]*p3mat[i][j][h];
- Line 6422  void  concatwav(int wav[], int **dh, int
+ Line 8798  void  concatwav(int wav[], int **dh, int
         }
         /* This for computing probability of death (h=1 means
            computed over hstepm matrices product = hstepm*stepm months)
-           as a weighted average of prlim.
+           as a weighted average of prlim. j is death. gmp[3]=sum_i w_i*p_i3=p.3 minus theta
         */
-        for(j=nlstate+1;j<=nlstate+ndeath;j++){
+        for(j=nlstate+1;j<=nlstate+ndeath;j++){  /* Currently only once theta_minus  p.3=Sum_i wi pi3*/
           for(i=1,gmp[j]=0.; i<= nlstate; i++)
             gmp[j] += prlim[i][i]*p3mat[i][j][1];
         }
         /* end shifting computations */
-        /**< Computing gradient matrix at horizon h
+        /**< Computing gradient of p.j matrix at horizon h and still for one parameter of vector theta
+         * equation 31 and 32
          */
-        for(j=1; j<= nlstate; j++) /* vareij */
+        for(j=1; j<= nlstate; j++) /* computes grad p.j(x, over each  h) where p.j is Sum_i w_i*pij(x over h)
+                                   * equation 24 */
           for(h=0; h<=nhstepm; h++){
             gradg[h][theta][j]= (gp[h][j]-gm[h][j])/2./delti[theta];
           }
-        /**< Gradient of overall mortality p.3 (or p.j)
+        /**< Gradient of overall mortality p.3 (or p.death)
          */
-        for(j=nlstate+1; j<= nlstate+ndeath; j++){ /* var mu mortality from j */
+        for(j=nlstate+1; j<= nlstate+ndeath; j++){ /* computes grad of p.3 from wi+pi3 grad p.3 (theta) */
           gradgp[theta][j]= (gpp[j]-gmp[j])/2./delti[theta];
         }
       } /* End theta */
-      /* We got the gradient matrix for each theta and state j */
+      /* We got the gradient matrix for each theta and each state j of gradg(h]theta][j)=grad(_hp.j(theta) */
-      trgradg =ma3x(0,nhstepm,1,nlstate,1,npar); /* veij */
+      trgradg =ma3x(0,nhstepm,1,nlstate,1,npar);
-      for(h=0; h<=nhstepm; h++) /* veij */
+      for(h=0; h<=nhstepm; h++) /* veij */ /* computes the transposed of grad  (_hp.j(theta)*/
         for(j=1; j<=nlstate;j++)
           for(theta=1; theta <=npar; theta++)
             trgradg[h][j][theta]=gradg[h][theta][j];
-      for(j=nlstate+1; j<=nlstate+ndeath;j++) /* mu */
+      for(j=nlstate+1; j<=nlstate+ndeath;j++) /* computes transposed of grad p.3 (theta)*/
         for(theta=1; theta <=npar; theta++)
           trgradgp[j][theta]=gradgp[theta][j];
       /**< as well as its transposed matrix
- Line 6464  void  concatwav(int wav[], int **dh, int
+ Line 8842  void  concatwav(int wav[], int **dh, int
           vareij[i][j][(int)age] =0.;
       /* Computing trgradg by matcov by gradg at age and summing over h
-       * and k (nhstepm) formula 15 of article
+       * and k (nhstepm) formula 32 of article
-       * Lievre-Brouard-Heathcote
+       * Lievre-Brouard-Heathcote so that for each j, computes the cov(e.j,e.k) (formula 31).
+       * for given h and k computes trgradg[h](i,j) matcov (theta) gradg(k)(i,j) into vareij[i][j] which is
+       cov(e.i,e.j) and sums on h and k
+       * including the covariances.
        */
       for(h=0;h<=nhstepm;h++){
- Line 6474  void  concatwav(int wav[], int **dh, int
+ Line 8855  void  concatwav(int wav[], int **dh, int
           matprod2(doldm,dnewm,1,nlstate,1,npar,1,nlstate,gradg[k]);
           for(i=1;i<=nlstate;i++)
             for(j=1;j<=nlstate;j++)
-              vareij[i][j][(int)age] += doldm[i][j]*hf*hf;
+              vareij[i][j][(int)age] += doldm[i][j]*hf*hf; /* This is vareij=sum_h sum_k trgrad(h_pij) V(theta) grad(k_pij)
+                                                              including the covariances of e.j */
         }
       }
-      /* pptj is p.3 or p.j = trgradgp by cov by gradgp, variance of
+      /* Mortality: pptj is p.3 or p.death = trgradgp by cov by gradgp, variance of
-       * p.j overall mortality formula 49 but computed directly because
+       * p.3=1-p..=1-sum i p.i  overall mortality computed directly because
        * we compute the grad (wix pijx) instead of grad (pijx),even if
        * wix is independent of theta.
        */
       matprod2(dnewmp,trgradgp,nlstate+1,nlstate+ndeath,1,npar,1,npar,matcov);
       matprod2(doldmp,dnewmp,nlstate+1,nlstate+ndeath,1,npar,nlstate+1,nlstate+ndeath,gradgp);
       for(j=nlstate+1;j<=nlstate+ndeath;j++)
         for(i=nlstate+1;i<=nlstate+ndeath;i++)
-          varppt[j][i]=doldmp[j][i];
+          varppt[j][i]=doldmp[j][i];  /* This is the variance of p.3 */
       /* end ppptj */
       /*  x centered again */
- Line 6510  void  concatwav(int wav[], int **dh, int
+ Line 8892  void  concatwav(int wav[], int **dh, int
       hpxij(p3mat,nhstepm,age,hstepm,x,nlstate,stepm,oldm,savm, ij, nres);
       for(j=nlstate+1;j<=nlstate+ndeath;j++){
         for(i=1,gmp[j]=0.;i<= nlstate; i++)
-          gmp[j] += prlim[i][i]*p3mat[i][j][1];
+          gmp[j] += prlim[i][i]*p3mat[i][j][1]; /* gmp[j] is p.3 */
       }
       /* end probability of death */
       fprintf(ficresprobmorprev,"%3d %d ",(int) age, ij);
       for(j=nlstate+1; j<=(nlstate+ndeath);j++){
-        fprintf(ficresprobmorprev," %11.3e %11.3e",gmp[j], sqrt(varppt[j][j]));
+        fprintf(ficresprobmorprev," %11.3e %11.3e",gmp[j], sqrt(varppt[j][j]));/* p.3 (STD p.3) */
         for(i=1; i<=nlstate;i++){
-          fprintf(ficresprobmorprev," %11.3e %11.3e ",prlim[i][i],p3mat[i][j][1]);
+          fprintf(ficresprobmorprev," %11.3e %11.3e ",prlim[i][i],p3mat[i][j][1]); /* wi, pi3 */
         }
       }
       fprintf(ficresprobmorprev,"\n");
- Line 6844  void varprob(char optionfilefiname[], do
+ Line 9226  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 6916  To be simple, these graphs help to under
+ Line 9298  To be simple, these graphs help to under
     tj = (int) pow(2,cptcoveff);
     if (cptcovn<1) {tj=1;ncodemax[1]=1;}
     j1=0;
-    for(j1=1; j1<=tj;j1++){  /* For each valid combination of covariates or only once*/
-      for(nres=1;nres <=1; nres++){ /* For each resultline */
+    for(nres=1;nres <=nresult; nres++){ /* For each resultline */
-      /* for(nres=1;nres <=nresult; nres++){ /\* For each resultline *\/ */
+    for(j1=1; j1<=tj;j1++){ /* For any combination of dummy covariates, fixed and varying */
+      /* printf("Varprob  TKresult[nres]=%d j1=%d, nres=%d, cptcovn=%d, cptcoveff=%d tj=%d cptcovs=%d\n",  TKresult[nres], j1, nres, cptcovn, cptcoveff, tj, cptcovs); */
+      if(tj != 1 && TKresult[nres]!= j1)
+        continue;
+    /* for(j1=1; j1<=tj;j1++){  /\* For each valid combination of covariates or only once*\/ */
+      /* for(nres=1;nres <=1; nres++){ /\* For each resultline *\/ */
+      /* /\* for(nres=1;nres <=nresult; nres++){ /\\* For each resultline *\\/ *\/ */
       if  (cptcovn>0) {
         fprintf(ficresprob, "\n#********** Variable ");
-        for (z1=1; z1<=cptcoveff; z1++) fprintf(ficresprob, "V%d=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
-        fprintf(ficresprob, "**********\n#\n");
         fprintf(ficresprobcov, "\n#********** Variable ");
-        for (z1=1; z1<=cptcoveff; z1++) fprintf(ficresprobcov, "V%d=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
+        fprintf(ficgp, "\n#********** Variable ");
+        fprintf(fichtmcov, "\n<hr  size=\"2\" color=\"#EC5E5E\">********** Variable ");
+        fprintf(ficresprobcor, "\n#********** Variable ");
+        /* Including quantitative variables of the resultline to be done */
+        for (z1=1; z1<=cptcovs; z1++){ /* Loop on each variable of this resultline  */
+          /* printf("Varprob modelresult[%d][%d]=%d model=1+age+%s \n",nres, z1, modelresult[nres][z1], model); */
+          fprintf(ficlog,"Varprob modelresult[%d][%d]=%d model=1+age+%s \n",nres, z1, modelresult[nres][z1], model);
+          /* fprintf(ficlog,"Varprob modelresult[%d][%d]=%d model=1+age+%s resultline[%d]=%s \n",nres, z1, modelresult[nres][z1], model, nres, resultline[nres]); */
+          if(Dummy[modelresult[nres][z1]]==0){/* Dummy variable of the variable in position modelresult in the model corresponding to z1 in resultline  */
+            if(Fixed[modelresult[nres][z1]]==0){ /* Fixed referenced to model equation */
+              fprintf(ficresprob,"V%d=%d ",Tvresult[nres][z1],Tresult[nres][z1]); /* Output of each value for the combination TKresult[nres], ordere by the covariate values in the resultline  */
+              fprintf(ficresprobcov,"V%d=%d ",Tvresult[nres][z1],Tresult[nres][z1]); /* Output of each value for the combination TKresult[nres], ordere by the covariate values in the resultline  */
+              fprintf(ficgp,"V%d=%d ",Tvresult[nres][z1],Tresult[nres][z1]); /* Output of each value for the combination TKresult[nres], ordere by the covariate values in the resultline  */
+              fprintf(fichtmcov,"V%d=%d ",Tvresult[nres][z1],Tresult[nres][z1]); /* Output of each value for the combination TKresult[nres], ordere by the covariate values in the resultline  */
+              fprintf(ficresprobcor,"V%d=%d ",Tvresult[nres][z1],Tresult[nres][z1]); /* Output of each value for the combination TKresult[nres], ordere by the covariate values in the resultline  */
+              fprintf(ficresprob,"fixed ");
+              fprintf(ficresprobcov,"fixed ");
+              fprintf(ficgp,"fixed ");
+              fprintf(fichtmcov,"fixed ");
+              fprintf(ficresprobcor,"fixed ");
+            }else{
+              fprintf(ficresprob,"varyi ");
+              fprintf(ficresprobcov,"varyi ");
+              fprintf(ficgp,"varyi ");
+              fprintf(fichtmcov,"varyi ");
+              fprintf(ficresprobcor,"varyi ");
+            }
+          }else if(Dummy[modelresult[nres][z1]]==1){ /* Quanti variable */
+            /* For each selected (single) quantitative value */
+            fprintf(ficresprob," V%d=%lg ",Tvqresult[nres][z1],Tqresult[nres][z1]);
+            if(Fixed[modelresult[nres][z1]]==0){ /* Fixed */
+              fprintf(ficresprob,"fixed ");
+              fprintf(ficresprobcov,"fixed ");
+              fprintf(ficgp,"fixed ");
+              fprintf(fichtmcov,"fixed ");
+              fprintf(ficresprobcor,"fixed ");
+            }else{
+              fprintf(ficresprob,"varyi ");
+              fprintf(ficresprobcov,"varyi ");
+              fprintf(ficgp,"varyi ");
+              fprintf(fichtmcov,"varyi ");
+              fprintf(ficresprobcor,"varyi ");
+            }
+          }else{
+            printf("Error in varprob() Dummy[modelresult[%d][%d]]=%d, modelresult[%d][%d]=V%d cptcovs=%d, cptcoveff=%d \n", nres, z1, Dummy[modelresult[nres][z1]],nres,z1,modelresult[nres][z1],cptcovs, cptcoveff);  /* end if dummy  or quanti */
+            fprintf(ficlog,"Error in varprob() Dummy[modelresult[%d][%d]]=%d, modelresult[%d][%d]=V%d cptcovs=%d, cptcoveff=%d \n", nres, z1, Dummy[modelresult[nres][z1]],nres,z1,modelresult[nres][z1],cptcovs, cptcoveff);  /* end if dummy  or quanti */
+            exit(1);
+          }
+        } /* End loop on variable of this resultline */
+        /* for (z1=1; z1<=cptcoveff; z1++) fprintf(ficresprob, "V%d=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,TnsdVar[Tvaraff[z1]])]); */
+        fprintf(ficresprob, "**********\n#\n");
         fprintf(ficresprobcov, "**********\n#\n");
-        fprintf(ficgp, "\n#********** Variable ");
-        for (z1=1; z1<=cptcoveff; z1++) fprintf(ficgp, " V%d=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
         fprintf(ficgp, "**********\n#\n");
-        fprintf(fichtmcov, "\n<hr  size=\"2\" color=\"#EC5E5E\">********** Variable ");
-        /* for (z1=1; z1<=cptcoveff; z1++) fprintf(fichtm, "V%d=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]); */
-        for (z1=1; z1<=cptcoveff; z1++) fprintf(fichtmcov, "V%d=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
         fprintf(fichtmcov, "**********\n<hr size=\"2\" color=\"#EC5E5E\">");
-        fprintf(ficresprobcor, "\n#********** Variable ");
-        for (z1=1; z1<=cptcoveff; z1++) fprintf(ficresprobcor, "V%d=%d ",Tvaraff[z1],nbcode[Tvaraff[z1]][codtabm(j1,z1)]);
         fprintf(ficresprobcor, "**********\n#");
         if(invalidvarcomb[j1]){
           fprintf(ficgp,"\n#Combination (%d) ignored because no cases \n",j1);
- Line 6950  To be simple, these graphs help to under
+ Line 9377  To be simple, these graphs help to under
       trgradg=matrix(1,(nlstate)*(nlstate+ndeath),1,npar);
       gp=vector(1,(nlstate)*(nlstate+ndeath));
       gm=vector(1,(nlstate)*(nlstate+ndeath));
-      for (age=bage; age<=fage; age ++){
+      for (age=bage; age<=fage; age ++){ /* Fo each age we feed the model equation with covariates, using precov as in hpxij() ? */
         cov[2]=age;
         if(nagesqr==1)
           cov[3]= age*age;
-        /* for (k=1; k<=cptcovn;k++) { */
+        /* New code end of combination but for each resultline */
-        /*        cov[2+nagesqr+k]=nbcode[Tvar[k]][codtabm(j1,k)]; */
+        for(k1=1;k1<=cptcovt;k1++){ /* loop on model equation (including products) */
-        for (k=1; k<=nsd;k++) { /* For single dummy covariates only */
+          if(Typevar[k1]==1 || Typevar[k1] ==3){ /* A product with age */
-          /* Here comes the value of the covariate 'j1' after renumbering k with single dummy covariates */
+            cov[2+nagesqr+k1]=precov[nres][k1]*cov[2];
-          cov[2+nagesqr+TvarsDind[k]]=nbcode[TvarsD[k]][codtabm(j1,k)];
-          /*cov[2+nagesqr+k]=nbcode[Tvar[k]][codtabm(j1,Tvar[k])];*//* j1 1 2 3 4
-                                                                     * 1  1 1 1 1
-                                                                     * 2  2 1 1 1
-                                                                     * 3  1 2 1 1
-                                                                     */
-          /* nbcode[1][1]=0 nbcode[1][2]=1;*/
-        }
-        /* V2+V1+V4+V3*age Tvar[4]=3 ; V1+V2*age Tvar[2]=2; V1+V1*age Tvar[2]=1, Tage[1]=2 */
-        /* ) p nbcode[Tvar[Tage[k]]][(1 & (ij-1) >> (k-1))+1] */
-        /*for (k=1; k<=cptcovage;k++) cov[2+Tage[k]]=cov[2+Tage[k]]*cov[2]; */
-        for (k=1; k<=cptcovage;k++){  /* For product with age */
-          if(Dummy[Tage[k]]==2){ /* dummy with age */
-            cov[2+nagesqr+Tage[k]]=nbcode[Tvar[Tage[k]]][codtabm(j1,k)]*cov[2];
-            /* cov[++k1]=nbcode[Tvar[Tage[k]]][codtabm(ij,k)]*cov[2]; */
-          } else if(Dummy[Tage[k]]==3){ /* quantitative with age */
-            printf("Internal IMaCh error, don't know which value for quantitative covariate with age, Tage[k]%d, k=%d, Tvar[Tage[k]]=V%d, age=%d\n",Tage[k],k ,Tvar[Tage[k]], (int)cov[2]);
-            exit(1);
-              /* cov[2+nagesqr+Tage[k]]=meanq[k]/idq[k]*cov[2];/\* Using the mean of quantitative variable Tvar[Tage[k]] /\* Tqresult[nres][k]; *\/ */
-            /* cov[++k1]=Tqresult[nres][k];  */
-          }
-          /* cov[2+Tage[k]+nagesqr]=nbcode[Tvar[Tage[k]]][codtabm(ij,k)]*cov[2]; */
-        }
-        for (k=1; k<=cptcovprod;k++){/* For product without age */
-          if(Dummy[Tvard[k][1]==0]){
-            if(Dummy[Tvard[k][2]==0]){
-              cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(j1,k)] * nbcode[Tvard[k][2]][codtabm(j1,k)];
-              /* cov[++k1]=nbcode[Tvard[k][1]][codtabm(ij,k)] * nbcode[Tvard[k][2]][codtabm(ij,k)]; */
-            }else{ /* Should we use the mean of the quantitative variables? */
-              cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(j1,k)] * Tqresult[nres][k];
-              /* cov[++k1]=nbcode[Tvard[k][1]][codtabm(ij,k)] * Tqresult[nres][k]; */
-            }
           }else{
-            if(Dummy[Tvard[k][2]==0]){
+            cov[2+nagesqr+k1]=precov[nres][k1];
-              cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][2]][codtabm(j1,k)] * Tqinvresult[nres][Tvard[k][1]];
-              /* cov[++k1]=nbcode[Tvard[k][2]][codtabm(ij,k)] * Tqinvresult[nres][Tvard[k][1]]; */
-            }else{
-              cov[2+nagesqr+Tprod[k]]=Tqinvresult[nres][Tvard[k][1]]*  Tqinvresult[nres][Tvard[k][2]];
-              /* cov[++k1]=Tqinvresult[nres][Tvard[k][1]]*  Tqinvresult[nres][Tvard[k][2]]; */
-            }
           }
-          /* cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)]*nbcode[Tvard[k][2]][codtabm(ij,k)]; */
+        }/* End of loop on model equation */
-        }
+ /* Old code */
+        /* /\* for (k=1; k<=cptcovn;k++) { *\/ */
+        /* /\*    cov[2+nagesqr+k]=nbcode[Tvar[k]][codtabm(j1,k)]; *\/ */
+        /* for (k=1; k<=nsd;k++) { /\* For single dummy covariates only *\/ */
+        /*        /\* Here comes the value of the covariate 'j1' after renumbering k with single dummy covariates *\/ */
+        /*        cov[2+nagesqr+TvarsDind[k]]=nbcode[TvarsD[k]][codtabm(j1,TnsdVar[TvarsD[k]])]; */
+        /*        /\*cov[2+nagesqr+k]=nbcode[Tvar[k]][codtabm(j1,Tvar[k])];*\//\* j1 1 2 3 4 */
+        /*                                                                   * 1  1 1 1 1 */
+        /*                                                                   * 2  2 1 1 1 */
+        /*                                                                   * 3  1 2 1 1 */
+        /*                                                                   *\/ */
+        /*        /\* nbcode[1][1]=0 nbcode[1][2]=1;*\/ */
+        /* } */
+        /* /\* V2+V1+V4+V3*age Tvar[4]=3 ; V1+V2*age Tvar[2]=2; V1+V1*age Tvar[2]=1, Tage[1]=2 *\/ */
+        /* /\* ) p nbcode[Tvar[Tage[k]]][(1 & (ij-1) >> (k-1))+1] *\/ */
+        /* /\*for (k=1; k<=cptcovage;k++) cov[2+Tage[k]]=cov[2+Tage[k]]*cov[2]; *\/ */
+        /* for (k=1; k<=cptcovage;k++){  /\* For product with age *\/ */
+        /*        if(Dummy[Tage[k]]==2){ /\* dummy with age *\/ */
+        /*          cov[2+nagesqr+Tage[k]]=nbcode[Tvar[Tage[k]]][codtabm(j1,TnsdVar[Tvar[Tage[k]]])]*cov[2]; */
+        /*          /\* cov[++k1]=nbcode[Tvar[Tage[k]]][codtabm(ij,k)]*cov[2]; *\/ */
+        /*        } else if(Dummy[Tage[k]]==3){ /\* quantitative with age *\/ */
+        /*          printf("Internal IMaCh error, don't know which value for quantitative covariate with age, Tage[k]%d, k=%d, Tvar[Tage[k]]=V%d, age=%d\n",Tage[k],k ,Tvar[Tage[k]], (int)cov[2]); */
+        /*          /\* cov[2+nagesqr+Tage[k]]=meanq[k]/idq[k]*cov[2];/\\* Using the mean of quantitative variable Tvar[Tage[k]] /\\* Tqresult[nres][k]; *\\/ *\/ */
+        /*          /\* exit(1); *\/ */
+        /*          /\* cov[++k1]=Tqresult[nres][k];  *\/ */
+        /*        } */
+        /*        /\* cov[2+Tage[k]+nagesqr]=nbcode[Tvar[Tage[k]]][codtabm(ij,k)]*cov[2]; *\/ */
+        /* } */
+        /* for (k=1; k<=cptcovprod;k++){/\* For product without age *\/ */
+        /*        if(Dummy[Tvard[k][1]]==0){ */
+        /*          if(Dummy[Tvard[k][2]]==0){ */
+        /*            cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(j1,TnsdVar[Tvard[k][1]])] * nbcode[Tvard[k][2]][codtabm(j1,TnsdVar[Tvard[k][2]])]; */
+        /*            /\* cov[++k1]=nbcode[Tvard[k][1]][codtabm(ij,k)] * nbcode[Tvard[k][2]][codtabm(ij,k)]; *\/ */
+        /*          }else{ /\* Should we use the mean of the quantitative variables? *\/ */
+        /*            cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(j1,TnsdVar[Tvard[k][1]])] * Tqresult[nres][resultmodel[nres][k]]; */
+        /*            /\* cov[++k1]=nbcode[Tvard[k][1]][codtabm(ij,k)] * Tqresult[nres][k]; *\/ */
+        /*          } */
+        /*        }else{ */
+        /*          if(Dummy[Tvard[k][2]]==0){ */
+        /*            cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][2]][codtabm(j1,TnsdVar[Tvard[k][2]])] * Tqinvresult[nres][TnsdVar[Tvard[k][1]]]; */
+        /*            /\* cov[++k1]=nbcode[Tvard[k][2]][codtabm(ij,k)] * Tqinvresult[nres][Tvard[k][1]]; *\/ */
+        /*          }else{ */
+        /*            cov[2+nagesqr+Tprod[k]]=Tqinvresult[nres][TnsdVar[Tvard[k][1]]]*  Tqinvresult[nres][TnsdVar[Tvard[k][2]]]; */
+        /*            /\* cov[++k1]=Tqinvresult[nres][Tvard[k][1]]*  Tqinvresult[nres][Tvard[k][2]]; *\/ */
+        /*          } */
+        /*        } */
+        /*        /\* cov[2+nagesqr+Tprod[k]]=nbcode[Tvard[k][1]][codtabm(ij,k)]*nbcode[Tvard[k][2]][codtabm(ij,k)]; *\/ */
+        /* } */
  /* For each age and combination of dummy covariates we slightly move the parameters of delti in order to get the gradient*/
         for(theta=1; theta <=npar; theta++){
           for(i=1; i<=npar; i++)
- Line 7186  To be simple, these graphs help to under
+ Line 9622  To be simple, these graphs help to under
           } /* k12 */
         } /*l1 */
       }/* k1 */
-    } /* loop on nres */
     }  /* loop on combination of covariates j1 */
+    } /* loop on nres */
     free_ma3x(varpij,1,nlstate,1,nlstate+ndeath,(int) bage, (int)fage);
     free_matrix(mu,1,(nlstate+ndeath)*(nlstate+ndeath),(int) bage, (int)fage);
     free_matrix(doldm,1,(nlstate)*(nlstate+ndeath),1,(nlstate)*(nlstate+ndeath));
- Line 7208  void printinghtml(char fileresu[], char
+ Line 9644  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 7218  void printinghtml(char fileresu[], char
+ Line 9654  void printinghtml(char fileresu[], char
     fprintf(fichtm,"<ul><li><h4><a name='firstorder'>Result files (first order: no variance)</a></h4>\n");
     fprintf(fichtm,"<li>- Observed frequency between two states (during the period defined between %.lf/%.lf/%.lf and %.lf/%.lf/%.lf): <a href=\"%s\">%s</a> (html file)<br/>\n",
             jprev1, mprev1,anprev1,jprev2, mprev2,anprev2,subdirfext3(optionfilefiname,"PHTMFR_",".htm"),subdirfext3(optionfilefiname,"PHTMFR_",".htm"));
-    fprintf(fichtm,"<li> - Observed prevalence in each state (during the period defined between %.lf/%.lf/%.lf and %.lf/%.lf/%.lf): <a href=\"%s\">%s</a> (html file) ",
+    fprintf(fichtm,"<li> - Observed prevalence (cross-sectional prevalence) in each state (during the period defined between %.lf/%.lf/%.lf and %.lf/%.lf/%.lf): <a href=\"%s\">%s</a> (html file) ",
             jprev1, mprev1,anprev1,jprev2, mprev2,anprev2,subdirfext3(optionfilefiname,"PHTM_",".htm"),subdirfext3(optionfilefiname,"PHTM_",".htm"));
     fprintf(fichtm,",  <a href=\"%s\">%s</a> (text file) <br>\n",subdirf2(fileresu,"P_"),subdirf2(fileresu,"P_"));
     fprintf(fichtm,"\
- Line 7252  void printinghtml(char fileresu[], char
+ Line 9688  void printinghtml(char fileresu[], char
     jj1=0;
     fprintf(fichtm," \n<ul>");
-    for(nres=1; nres <= nresult; nres++) /* For each resultline */
+    for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-    for(k1=1; k1<=m;k1++){ /* For each combination of covariate */
+      /* k1=nres; */
-      if(m != 1 && TKresult[nres]!= k1)
+      k1=TKresult[nres];
-        continue;
+      if(TKresult[nres]==0)k1=1; /* To be checked for no result */
+    /* for(k1=1; k1<=m;k1++){ /\* For each combination of covariate *\/ */
+    /*   if(m != 1 && TKresult[nres]!= k1) */
+    /*     continue; */
       jj1++;
       if (cptcovn > 0) {
         fprintf(fichtm,"\n<li><a  size=\"1\" color=\"#EC5E5E\" href=\"#rescov");
-        for (cpt=1; cpt<=cptcoveff;cpt++){
+        for (cpt=1; cpt<=cptcovs;cpt++){ /**< cptcovs number of SIMPLE covariates in the model V2+V1 =2 (dummy or quantit or time varying) */
-          fprintf(fichtm,"_V%d=%d_",Tvresult[nres][cpt],(int)Tresult[nres][cpt]);
+          fprintf(fichtm,"_V%d=%lg_",Tvresult[nres][cpt],TinvDoQresult[nres][Tvresult[nres][cpt]]);
-        }
-        for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
-          fprintf(fichtm,"_V%d=%f_",Tvqresult[nres][k4],Tqresult[nres][k4]);
         }
+        /* for (cpt=1; cpt<=cptcoveff;cpt++){  */
+        /*        fprintf(fichtm,"_V%d=%d_",Tvresult[nres][cpt],(int)Tresult[nres][cpt]); */
+        /* } */
+        /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
+        /*        fprintf(fichtm,"_V%d=%f_",Tvqresult[nres][k4],Tqresult[nres][k4]); */
+        /* } */
         fprintf(fichtm,"\">");
         /* if(nqfveff+nqtveff 0) */ /* Test to be done */
         fprintf(fichtm,"************ Results for covariates");
-        for (cpt=1; cpt<=cptcoveff;cpt++){
+        for (cpt=1; cpt<=cptcovs;cpt++){
-          fprintf(fichtm," V%d=%d ",Tvresult[nres][cpt],(int)Tresult[nres][cpt]);
+          fprintf(fichtm," V%d=%lg ",Tvresult[nres][cpt],TinvDoQresult[nres][Tvresult[nres][cpt]]);
-        }
-        for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
-          fprintf(fichtm," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
         }
+        /* fprintf(fichtm,"************ Results for covariates"); */
+        /* for (cpt=1; cpt<=cptcoveff;cpt++){  */
+        /*        fprintf(fichtm," V%d=%d ",Tvresult[nres][cpt],(int)Tresult[nres][cpt]); */
+        /* } */
+        /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
+        /*        fprintf(fichtm," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]); */
+        /* } */
         if(invalidvarcomb[k1]){
           fprintf(fichtm," Warning Combination (%d) ignored because no cases ",k1);
           continue;
- Line 7286  void printinghtml(char fileresu[], char
+ Line 9732  void printinghtml(char fileresu[], char
     jj1=0;
-    for(nres=1; nres <= nresult; nres++) /* For each resultline */
+    for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-    for(k1=1; k1<=m;k1++){ /* For each combination of covariate */
+      /* k1=nres; */
-      if(m != 1 && TKresult[nres]!= k1)
+      k1=TKresult[nres];
-        continue;
+      if(TKresult[nres]==0) k1=1; /* To be checked for noresult */
+    /* for(k1=1; k1<=m;k1++){ /\* For each combination of covariate *\/ */
+    /*   if(m != 1 && TKresult[nres]!= k1) */
+    /*     continue; */
       /* for(i1=1; i1<=ncodemax[k1];i1++){ */
       jj1++;
       if (cptcovn > 0) {
         fprintf(fichtm,"\n<p><a name=\"rescov");
-        for (cpt=1; cpt<=cptcoveff;cpt++){
+        for (cpt=1; cpt<=cptcovs;cpt++){
-          fprintf(fichtm,"_V%d=%d_",Tvresult[nres][cpt],(int)Tresult[nres][cpt]);
+          fprintf(fichtm,"_V%d=%lg_",Tvresult[nres][cpt],TinvDoQresult[nres][Tvresult[nres][cpt]]);
-        }
-        for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
-          fprintf(fichtm,"_V%d=%f_",Tvqresult[nres][k4],Tqresult[nres][k4]);
         }
+        /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
+        /*        fprintf(fichtm,"_V%d=%f_",Tvqresult[nres][k4],Tqresult[nres][k4]); */
+        /* } */
         fprintf(fichtm,"\"</a>");
         fprintf(fichtm,"<hr  size=\"2\" color=\"#EC5E5E\">************ Results for covariates");
-        for (cpt=1; cpt<=cptcoveff;cpt++){
+        for (cpt=1; cpt<=cptcovs;cpt++){
-          fprintf(fichtm," V%d=%d ",Tvresult[nres][cpt],(int)Tresult[nres][cpt]);
+          fprintf(fichtm," V%d=%lg ",Tvresult[nres][cpt],TinvDoQresult[nres][Tvresult[nres][cpt]]);
-          printf(" V%d=%d ",Tvresult[nres][cpt],Tresult[nres][cpt]);fflush(stdout);
+          printf(" V%d=%lg ",Tvresult[nres][cpt],TinvDoQresult[nres][Tvresult[nres][cpt]]);
           /* fprintf(fichtm," V%d=%d ",Tvaraff[cpt],nbcode[Tvaraff[cpt]][codtabm(jj1,cpt)]); */
           /* printf(" V%d=%d ",Tvaraff[cpt],nbcode[Tvaraff[cpt]][codtabm(jj1,cpt)]);fflush(stdout); */
         }
-        for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
-         fprintf(fichtm," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
-         printf(" V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);fflush(stdout);
-       }
         /* if(nqfveff+nqtveff 0) */ /* Test to be done */
-        fprintf(fichtm," (model=%s) ************\n<hr size=\"2\" color=\"#EC5E5E\">",model);
+        fprintf(fichtm," (model=1+age+%s) ************\n<hr size=\"2\" color=\"#EC5E5E\">",model);
         if(invalidvarcomb[k1]){
           fprintf(fichtm,"\n<h3>Combination (%d) ignored because no cases </h3>\n",k1);
           printf("\nCombination (%d) ignored because no cases \n",k1);
- Line 7337  divided by h: <sub>h</sub>P<sub>ij</sub>
+ Line 9781  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> \
+        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);
- <img src=\"%s_%d-%d-%d.svg\">", cpt, cpt, nlstate, subdirf2(optionfilefiname,"LIJ_"),cpt,k1,nres,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> <img src=\"%s_%d-%d-%d.svg\">", cpt, nlstate, cpt, subdirf2(optionfilefiname,"LIJT_"),cpt,k1,nres,subdirf2(optionfilefiname,"LIJT_"),cpt,k1,nres,subdirf2(optionfilefiname,"LIJT_"),cpt,k1,nres);
+  <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> \
+        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);
- <img src=\"%s_%d-%d-%d.svg\">", cpt, nlstate, cpt, subdirf2(optionfilefiname,"P_"),cpt,k1,nres,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);
       }
       if(prevbcast==1){
         /* Backward prevalence in each health state */
         for(cpt=1; cpt<=nlstate;cpt++){
-          fprintf(fichtm,"<br>\n- Convergence to mixed (stable) back prevalence in state %d. Or probability for a person to be in state %d at a younger age, knowing that she/he was in state (1 to %d) at different older ages. <a href=\"%s_%d-%d-%d.svg\">%s_%d-%d-%d.svg</a><br> \
+          fprintf(fichtm,"<br>\n- Convergence to mixed (stable) back prevalence in state %d. Or probability for a person to be in state %d at a younger age, knowing that she/he was in state (1 to %d) at different older ages. <a href=\"%s_%d-%d-%d.svg\">%s_%d-%d-%d.svg</a><br>", cpt, cpt, nlstate, subdirf2(optionfilefiname,"PB_"),cpt,k1,nres,subdirf2(optionfilefiname,"PB_"),cpt,k1,nres);
- <img src=\"%s_%d-%d-%d.svg\">", cpt, cpt, nlstate, subdirf2(optionfilefiname,"PB_"),cpt,k1,nres,subdirf2(optionfilefiname,"PB_"),cpt,k1,nres,subdirf2(optionfilefiname,"PB_"),cpt,k1,nres);
+          fprintf(fichtm," (data from text file  <a href=\"%s.txt\">%s.txt</a>)\n<br>",subdirf2(optionfilefiname,"PIJB_"),subdirf2(optionfilefiname,"PIJB_"));
+          fprintf(fichtm,"<img src=\"%s_%d-%d-%d.svg\">" ,subdirf2(optionfilefiname,"PB_"),cpt,k1,nres);
         }
       }
       if(prevfcast==1){
- Line 7371  divided by h: <sub>h</sub>P<sub>ij</sub>
+ Line 9820  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 7385  with weights corresponding to observed p
+ Line 9834  with weights corresponding to observed p
         fprintf(fichtm,"<img src=\"%s_%d-%d-%d.svg\">", subdirf2(optionfilefiname,"EXP_"),cpt,k1,nres );
       }
       /* } /\* end i1 *\/ */
-    }/* End k1 */
+    }/* End k1=nres */
     fprintf(fichtm,"</ul>");
     fprintf(fichtm,"\
- Line 7432  See page 'Matrix of variance-covariance
+ Line 9881  See page 'Matrix of variance-covariance
  /*  - Population forecasting (if popforecast=1): <a href=\"pop%s\">pop%s</a> <br>\n */
  /*      <br>",fileres,fileres,fileres,fileres); */
  /*  else  */
- /*    fprintf(fichtm,"\n No population forecast: popforecast = %d (instead of 1) or stepm = %d (instead of 1) or model=%s (instead of .)<br><br></li>\n",popforecast, stepm, model); */
+ /*    fprintf(fichtm,"\n No population forecast: popforecast = %d (instead of 1) or stepm = %d (instead of 1) or model=1+age+%s (instead of .)<br><br></li>\n",popforecast, stepm, model); */
     fflush(fichtm);
     m=pow(2,cptcoveff);
- Line 7443  See page 'Matrix of variance-covariance
+ Line 9892  See page 'Matrix of variance-covariance
    jj1=0;
     fprintf(fichtm," \n<ul>");
-    for(nres=1; nres <= nresult; nres++) /* For each resultline */
+    for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-    for(k1=1; k1<=m;k1++){ /* For each combination of covariate */
+      /* k1=nres; */
-      if(m != 1 && TKresult[nres]!= k1)
+      k1=TKresult[nres];
-        continue;
+      /* for(k1=1; k1<=m;k1++){ /\* For each combination of covariate *\/ */
+      /* if(m != 1 && TKresult[nres]!= k1) */
+      /*   continue; */
       jj1++;
       if (cptcovn > 0) {
         fprintf(fichtm,"\n<li><a  size=\"1\" color=\"#EC5E5E\" href=\"#rescovsecond");
-        for (cpt=1; cpt<=cptcoveff;cpt++){
+        for (cpt=1; cpt<=cptcovs;cpt++){
-          fprintf(fichtm,"_V%d=%d_",Tvresult[nres][cpt],(int)Tresult[nres][cpt]);
+          fprintf(fichtm,"_V%d=%lg_",Tvresult[nres][cpt],TinvDoQresult[nres][Tvresult[nres][cpt]]);
-        }
-        for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
-          fprintf(fichtm,"_V%d=%f_",Tvqresult[nres][k4],Tqresult[nres][k4]);
         }
         fprintf(fichtm,"\">");
         /* if(nqfveff+nqtveff 0) */ /* Test to be done */
         fprintf(fichtm,"************ Results for covariates");
-        for (cpt=1; cpt<=cptcoveff;cpt++){
+        for (cpt=1; cpt<=cptcovs;cpt++){
-          fprintf(fichtm," V%d=%d ",Tvresult[nres][cpt],(int)Tresult[nres][cpt]);
+          fprintf(fichtm," V%d=%lg ",Tvresult[nres][cpt],TinvDoQresult[nres][Tvresult[nres][cpt]]);
-        }
-        for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
-          fprintf(fichtm," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
         }
         if(invalidvarcomb[k1]){
           fprintf(fichtm," Warning Combination (%d) ignored because no cases ",k1);
- Line 7472  See page 'Matrix of variance-covariance
+ Line 9917  See page 'Matrix of variance-covariance
         }
         fprintf(fichtm,"</a></li>");
       } /* cptcovn >0 */
-    }
+    } /* End nres */
     fprintf(fichtm," \n</ul>");
     jj1=0;
     for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-    for(k1=1; k1<=m;k1++){
+      /* k1=nres; */
-      if(m != 1 && TKresult[nres]!= k1)
+      k1=TKresult[nres];
-        continue;
+      if(TKresult[nres]==0) k1=1; /* To be checked for noresult */
+      /* for(k1=1; k1<=m;k1++){ */
+      /* if(m != 1 && TKresult[nres]!= k1) */
+      /*   continue; */
       /* for(i1=1; i1<=ncodemax[k1];i1++){ */
       jj1++;
       if (cptcovn > 0) {
         fprintf(fichtm,"\n<p><a name=\"rescovsecond");
-        for (cpt=1; cpt<=cptcoveff;cpt++){
+        for (cpt=1; cpt<=cptcovs;cpt++){
-          fprintf(fichtm,"_V%d=%d_",Tvresult[nres][cpt],(int)Tresult[nres][cpt]);
+          fprintf(fichtm,"_V%d=%lg_",Tvresult[nres][cpt],TinvDoQresult[nres][Tvresult[nres][cpt]]);
-        }
-        for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
-          fprintf(fichtm,"_V%d=%f_",Tvqresult[nres][k4],Tqresult[nres][k4]);
         }
         fprintf(fichtm,"\"</a>");
         fprintf(fichtm,"<hr  size=\"2\" color=\"#EC5E5E\">************ Results for covariates");
-        for (cpt=1; cpt<=cptcoveff;cpt++){  /**< cptcoveff number of variables */
+        for (cpt=1; cpt<=cptcovs;cpt++){  /**< cptcoveff number of variables */
-          fprintf(fichtm," V%d=%d ",Tvresult[nres][cpt],Tresult[nres][cpt]);
+          fprintf(fichtm," V%d=%lg ",Tvresult[nres][cpt],TinvDoQresult[nres][Tvresult[nres][cpt]]);
-          printf(" V%d=%d ",Tvresult[nres][cpt],Tresult[nres][cpt]);fflush(stdout);
+          printf(" V%d=%lg ",Tvresult[nres][cpt],TinvDoQresult[nres][Tvresult[nres][cpt]]);
           /* fprintf(fichtm," V%d=%d ",Tvaraff[cpt],nbcode[Tvaraff[cpt]][codtabm(jj1,cpt)]); */
         }
-        for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
-         fprintf(fichtm," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
-       }
-        fprintf(fichtm," (model=%s) ************\n<hr size=\"2\" color=\"#EC5E5E\">",model);
+        fprintf(fichtm," (model=1+age+%s) ************\n<hr size=\"2\" color=\"#EC5E5E\">",model);
         if(invalidvarcomb[k1]){
           fprintf(fichtm,"\n<h4>Combination (%d) ignored because no cases </h4>\n",k1);
           continue;
         }
-      }
+      } /* If cptcovn >0 */
       for(cpt=1; cpt<=nlstate;cpt++) {
         fprintf(fichtm,"\n<br>- Observed (cross-sectional with mov_average=%d) and period (incidence based) \
  prevalence (with 95%% confidence interval) in state (%d): <a href=\"%s_%d-%d-%d.svg\"> %s_%d-%d-%d.svg</a>",mobilav,cpt,subdirf2(optionfilefiname,"V_"),cpt,k1,nres,subdirf2(optionfilefiname,"V_"),cpt,k1,nres);
- Line 7517  prevalence (with 95%% confidence interva
+ Line 9959  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);
       fprintf(fichtm," (data from text file <a href=\"%s.txt\">%s.txt</a>) \n<br>",subdirf2(optionfilefiname,"T_"),subdirf2(optionfilefiname,"T_"));
       fprintf(fichtm,"<img src=\"%s_%d-%d.svg\">",subdirf2(optionfilefiname,"E_"),k1,nres);
       /* } /\* end i1 *\/ */
-    }/* End k1 */
    }/* End nres */
     fprintf(fichtm,"</ul>");
     fflush(fichtm);
- Line 7533  true period expectancies (those weighted
+ Line 9977  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,ij=0, ijp=0, l=0;
+   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;
    int vpopbased;
- Line 7561  void printinggnuplot(char fileresu[], ch
+ Line 10005  void printinggnuplot(char fileresu[], ch
    fprintf(ficgp,"yoff=(%d > 2? 0:1);\n",nlstate);
    fprintf(ficgp,"\n#Peripheral arrows\nset for [i=1:%d] for [j=1:%d] arrow i*10+j from cos(pi*((1-(%d/2)*2./%d)/2+(i-1)*2./%d))-(i!=j?(i-j)/abs(i-j)*delta:0), yoff +sin(pi*((1-(%d/2)*2./%d)/2+(i-1)*2./%d)) + (i!=j?(i-j)/abs(i-j)*delta:0) rto -0.95*(cos(pi*((1-(%d/2)*2./%d)/2+(i-1)*2./%d))+(i!=j?(i-j)/abs(i-j)*delta:0) - cos(pi*((1-(%d/2)*2./%d)/2+(j-1)*2./%d)) + (i!=j?(i-j)/abs(i-j)*delta2:0)), -0.95*(sin(pi*((1-(%d/2)*2./%d)/2+(i-1)*2./%d)) + (i!=j?(i-j)/abs(i-j)*delta:0) - sin(pi*((1-(%d/2)*2./%d)/2+(j-1)*2./%d))+( i!=j?(i-j)/abs(i-j)*delta2:0)) ls (i < j? 1:2)\n",nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate);
-   fprintf(ficgp,"\n#Centripete arrows (turning in other direction (1-i) instead of (i-1)) \nset for [i=1:%d] arrow (%d+1)*10+i from cos(pi*((1-(%d/2)*2./%d)/2+(1-i)*2./%d))-(i!=j?(i-j)/abs(i-j)*delta:0), yoff +sin(pi*((1-(%d/2)*2./%d)/2+(1-i)*2./%d)) + (i!=j?(i-j)/abs(i-j)*delta:0) rto -0.80*(cos(pi*((1-(%d/2)*2./%d)/2+(1-i)*2./%d))+(i!=j?(i-j)/abs(i-j)*delta:0)  ), -0.80*(sin(pi*((1-(%d/2)*2./%d)/2+(1-i)*2./%d)) + (i!=j?(i-j)/abs(i-j)*delta:0) + yoff ) ls 4\n",nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate);
+   fprintf(ficgp,"\n#Centripete arrows (turning in other direction (1-i) instead of (i-1)) \nset for [i=1:%d] for [j=1:%d] arrow (%d+1)*10+i from cos(pi*((1-(%d/2)*2./%d)/2+(1-i)*2./%d))-(i!=j?(i-j)/abs(i-j)*delta:0), yoff +sin(pi*((1-(%d/2)*2./%d)/2+(1-i)*2./%d)) + (i!=j?(i-j)/abs(i-j)*delta:0) rto -0.80*(cos(pi*((1-(%d/2)*2./%d)/2+(1-i)*2./%d))+(i!=j?(i-j)/abs(i-j)*delta:0)  ), -0.80*(sin(pi*((1-(%d/2)*2./%d)/2+(1-i)*2./%d)) + (i!=j?(i-j)/abs(i-j)*delta:0) + yoff ) ls 4\n",nlstate, nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate);
    fprintf(ficgp,"\n#show arrow\nunset label\n");
    fprintf(ficgp,"\n#States labels, starting from 2 (2-i) instead of (1-i), was (i-1)\nset for [i=1:%d] label i sprintf(\"State %%d\",i) center at cos(pi*((1-(%d/2)*2./%d)/2+(2-i)*2./%d)), yoff+sin(pi*((1-(%d/2)*2./%d)/2+(2-i)*2./%d)) font \"helvetica, 16\" tc rgbcolor \"blue\"\n",nlstate,nlstate,nlstate,nlstate,nlstate,nlstate,nlstate);
    fprintf(ficgp,"\nset label %d+1 sprintf(\"State %%d\",%d+1) center at 0.,0.  font \"helvetica, 16\" tc rgbcolor \"red\"\n",nlstate,nlstate);
- Line 7598  void printinggnuplot(char fileresu[], ch
+ Line 10042  void printinggnuplot(char fileresu[], ch
    fprintf(ficgp,"\nset out;unset log\n");
    /* fprintf(ficgp,"\nset out \"%s.svg\"; replot; set out; # bug gnuplot",subdirf2(optionfilefiname,"ILK_")); */
+   /* Plot the probability implied in the likelihood by covariate value */
+   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 name */
+     /* 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));
+       if(gnuplotversion >=5.2){ /* Former gnuplot versions do not have variable pointsize!! */
+         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);
+         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");
+     }
+   } /* End of each covariate dummy */
+   for(ncovv=1, iposold=0, kk=0; ncovv <= ncovvt ; ncovv++){
+     /* Other example        V1 + V3 + V5 + age*V1  + age*V3 + age*V5 + V1*V3  + V3*V5  + V1*V5
+      *     kmodel       =     1   2     3     4         5        6        7       8        9
+      *  varying                   1     2                                 3       4        5
+      *  ncovv                     1     2                                3 4     5 6      7 8
+      * TvarVV[ncovv]             V3     5                                1 3     3 5      1 5
+      * TvarVVind[ncovv]=kmodel    2     3                                7 7     8 8      9 9
+      * TvarFind[kmodel]       1   0     0     0         0        0        0       0        0
+      * kdata     ncovcol=[V1 V2] nqv=0 ntv=[V3 V4] nqtv=V5
+      * Dummy[kmodel]          0   0     1     2         2        3        1       1        1
+      */
+     ipos=TvarVVind[ncovv]; /* TvarVVind={2, 5, 5] gives the position in the model of the ncovv th varying covariate */
+     kvar=TvarVV[ncovv]; /*  TvarVV={3, 1, 3} gives the name of each varying covariate */
+     /* printf("DebugILK ficgp ncovv=%d, kvar=TvarVV[ncovv]=%d, ipos=TvarVVind[ncovv]=%d, Dummy[ipos]=%d, Typevar[ipos]=%d\n", ncovv,kvar,ipos,Dummy[ipos],Typevar[ipos]); */
+     if(ipos!=iposold){ /* Not a product or first of a product */
+       /* printf(" %d",ipos); */
+       /* fprintf(ficresilk," V%d",TvarVV[ncovv]); */
+       /* printf(" DebugILK ficgp suite ipos=%d != iposold=%d\n", ipos, iposold); */
+       kk++; /* Position of the ncovv column in ILK_ */
+       k=18+ncovf+kk; /*offset because there are 18 columns in the ILK_ file plus ncovf fixed covariate */
+       if(Dummy[ipos]==0 && Typevar[ipos]==0){ /* Only if dummy time varying: Dummy(0, 1=quant singor prod without age,2 dummy*age, 3quant*age) Typevar (0 single, 1=*age,2=Vn*vm)  */
+         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));
+             /* 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);
+             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{
+             /* printf("DebugILK gnuplotversion=%g <5.2\n",gnuplotversion); */
+             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");
+         }
+       }/* End if dummy varying */
+     }else{ /*Product */
+       /* printf("*"); */
+       /* fprintf(ficresilk,"*"); */
+     }
+     iposold=ipos;
+   } /* For each time varying covariate */
+   /* } /\* debugILK==1 *\/ */
+   /* unset log; plot  "rrtest1_sorted_4/ILK_rrtest1_sorted_4.txt" u  2:($4 == 1 && $5==2 ? $9 : 1/0):5 t "p12" with points lc variable */
+   /* fprintf(ficgp,"\nset log y;plot  \"%s\" u 2:(-$11):3 t \"All sample, all transitions\" with dots lc variable",subdirf(fileresilk)); */
+   /* fprintf(ficgp,"\nreplot  \"%s\" u 2:($3 <= 3 ? -$11 : 1/0):3 t \"First 3 individuals\" with line lc variable", subdirf(fileresilk)); */
+   fprintf(ficgp,"\nset out;unset log\n");
+   /* fprintf(ficgp,"\nset out \"%s.svg\"; replot; set out; # bug gnuplot",subdirf2(optionfilefiname,"ILK_")); */
    strcpy(dirfileres,optionfilefiname);
    strcpy(optfileres,"vpl");
    /* 1eme*/
    for (cpt=1; cpt<= nlstate ; cpt ++){ /* For each live state */
-     for (k1=1; k1<= m ; k1 ++){ /* For each valid combination of covariate */
+     /* for (k1=1; k1<= m ; k1 ++){ /\* For each valid combination of covariate *\/ */
        for(nres=1; nres <= nresult; nres++){ /* For each resultline */
+         k1=TKresult[nres];
+         if(TKresult[nres]==0) k1=1; /* To be checked for noresult */
          /* plot [100000000000000000000:-100000000000000000000] "mysbiaspar/vplrmysbiaspar.txt to check */
-         if(m != 1 && TKresult[nres]!= k1)
+         /* if(m != 1 && TKresult[nres]!= k1) */
-           continue;
+         /*   continue; */
          /* We are interested in selected combination by the resultline */
          /* printf("\n# 1st: Period (stable) prevalence with CI: 'VPL_' files and live state =%d ", cpt); */
          fprintf(ficgp,"\n# 1st: Forward (stable period) prevalence with CI: 'VPL_' files  and live state =%d ", cpt);
          strcpy(gplotlabel,"(");
-         for (k=1; k<=cptcoveff; k++){    /* For each covariate k get corresponding value lv for combination k1 */
+         for (k=1; k<=cptcovs; k++){    /* For each covariate k get corresponding value lv for combination k1 */
-           lv= decodtabm(k1,k,cptcoveff); /* Should be the value of the covariate corresponding to k1 combination */
+           fprintf(ficgp," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-           /* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 */
+           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-           /* 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 */
+         /* for (k=1; k<=cptcoveff; k++){    /\* For each covariate k get corresponding value lv for combination k1 *\/ */
-           vlv= nbcode[Tvaraff[k]][lv]; /* vlv is the value of the covariate lv, 0 or 1 */
+         /*   /\* lv= decodtabm(k1,k,cptcoveff); /\\* Should be the value of the covariate corresponding to k1 combination *\\/ *\/ */
-           /* For each combination of covariate k1 (V1=1, V3=0), we printed the current covariate k and its value vlv */
+         /*   lv=codtabm(k1,TnsdVar[Tvaraff[k]]); */
-           /* printf(" V%d=%d ",Tvaraff[k],vlv); */
+         /*   /\* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 *\/ */
-           fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv);
+         /*   /\* decodtabm(1,2,4) = 1 because h=1  k=  1 (1) 1  1 *\/ */
-           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv);
+         /*   /\* decodtabm(13,3,4)= 2 because h=13 k=  1  1 (2) 2 *\/ */
-         }
+         /*   vlv= nbcode[Tvaraff[k]][lv]; /\* vlv is the value of the covariate lv, 0 or 1 *\/ */
-         for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
+         /*   /\* For each combination of covariate k1 (V1=1, V3=0), we printed the current covariate k and its value vlv *\/ */
-           /* printf(" V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]); */
+         /*   /\* printf(" V%d=%d ",Tvaraff[k],vlv); *\/ */
-           fprintf(ficgp," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+         /*   fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv); */
-           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+         /*   sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv); */
+         /* } */
+         /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
+         /*   /\* printf(" V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]); *\/ */
+         /*   fprintf(ficgp," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]); */
+         /*   sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]); */
          }
          strcpy(gplotlabel+strlen(gplotlabel),")");
          /* printf("\n#\n"); */
- Line 7639  void printinggnuplot(char fileresu[], ch
+ Line 10173  void printinggnuplot(char fileresu[], ch
          fprintf(ficgp,"\nset out \"%s_%d-%d-%d.svg\" \n",subdirf2(optionfilefiname,"V_"),cpt,k1,nres);
          fprintf(ficgp,"\n#set out \"V_%s_%d-%d-%d.svg\" \n",optionfilefiname,cpt,k1,nres);
          /* fprintf(ficgp,"set label \"Alive state %d %s\" at graph 0.98,0.5 center rotate font \"Helvetica,12\"\n",cpt,gplotlabel); */
-         fprintf(ficgp,"set title \"Alive state %d %s model=%s\" font \"Helvetica,12\"\n",cpt,gplotlabel,model);
+         fprintf(ficgp,"set title \"Alive state %d %s model=1+age+%s\" font \"Helvetica,12\"\n",cpt,gplotlabel,model);
          fprintf(ficgp,"set xlabel \"Age\" \nset ylabel \"Probability\" \nset ter svg size 640, 480\nplot [%.f:%.f] \"%s\" every :::%d::%d u 1:($2==%d ? $3:1/0) \"%%lf %%lf",ageminpar,fage,subdirf2(fileresu,"VPL_"),nres-1,nres-1,nres);
          /* fprintf(ficgp,"set xlabel \"Age\" \nset ylabel \"Probability\" \nset ter svg size 640, 480\nplot [%.f:%.f] \"%s\" every :::%d::%d u 1:($2==%d ? $3:1/0) \"%%lf %%lf",ageminpar,fage,subdirf2(fileresu,"VPL_"),k1-1,k1-1,nres); */
        /* k1-1 error should be nres-1*/
- Line 7665  void printinggnuplot(char fileresu[], ch
+ Line 10199  void printinggnuplot(char fileresu[], ch
          }else{
            kl=0;
            for (k=1; k<=cptcoveff; k++){    /* For each combination of covariate  */
-             lv= decodtabm(k1,k,cptcoveff); /* Should be the covariate value corresponding to k1 combination and kth covariate */
+             /* lv= decodtabm(k1,k,cptcoveff); /\* Should be the covariate value corresponding to k1 combination and kth covariate *\/ */
+             lv=codtabm(k1,TnsdVar[Tvaraff[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 */
- Line 7693  void printinggnuplot(char fileresu[], ch
+ Line 10228  void printinggnuplot(char fileresu[], ch
            }else{
              kl=0;
              for (k=1; k<=cptcoveff; k++){    /* For each combination of covariate  */
-               lv= decodtabm(k1,k,cptcoveff); /* Should be the covariate value corresponding to k1 combination and kth covariate */
+               /* lv= decodtabm(k1,k,cptcoveff); /\* Should be the covariate value corresponding to k1 combination and kth covariate *\/ */
+               lv=codtabm(k1,TnsdVar[Tvaraff[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];
+               /* vlv= nbcode[Tvaraff[k]][lv]; */
+               vlv= nbcode[Tvaraff[k]][codtabm(k1,TnsdVar[Tvaraff[k]])];
                kl++;
                /* kl=6+(cpt-1)*(nlstate+1)+1+(i-1); /\* 6+(1-1)*(2+1)+1+(1-1)=7, 6+(2-1)(2+1)+1+(1-1)=10 *\/ */
                /*6+(cpt-1)*(nlstate+1)+1+(i-1)+(nlstate+1)*nlstate; 6+(1-1)*(2+1)+1+(1-1) +(2+1)*2=13 */
- Line 7707  void printinggnuplot(char fileresu[], ch
+ Line 10244  void printinggnuplot(char fileresu[], ch
                  fprintf(ficgp,"$%d==%d && $%d==%d)? $%d : 1/0) t 'Backward prevalence in state %d' w l lt 3",kl+1, Tvaraff[k],kl+1+1,nbcode[Tvaraff[k]][lv], \
 +cptcoveff*2+(cpt-1),  cpt );  /* 4 or 6 ?*/
                }else{
-                 fprintf(ficgp,"$%d==%d && $%d==%d && ",kl+1, Tvaraff[k],kl+1+1,nbcode[Tvaraff[k]][lv]);
+                 fprintf(ficgp,"$%d==%d && $%d==%d && ",kl+1, Tvaraff[k],kl+1+1,nbcode[Tvaraff[k]][codtabm(k1,TnsdVar[Tvaraff[k]])]);
                  kl++;
                }
              } /* end covariate */
- Line 7735  void printinggnuplot(char fileresu[], ch
+ Line 10272  void printinggnuplot(char fileresu[], ch
          /* fprintf(ficgp,"\nset out ;unset label;\n"); */
          fprintf(ficgp,"\nset out ;unset title;\n");
        } /* nres */
-     } /* k1 */
+     /* } /\* k1 *\/ */
    } /* cpt */
    /*2 eme*/
-   for (k1=1; k1<= m ; k1 ++){
+   /* for (k1=1; k1<= m ; k1 ++){   */
      for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-       if(m != 1 && TKresult[nres]!= k1)
+       k1=TKresult[nres];
-         continue;
+       if(TKresult[nres]==0) k1=1; /* To be checked for noresult */
+       /* if(m != 1 && TKresult[nres]!= k1) */
+       /*        continue; */
        fprintf(ficgp,"\n# 2nd: Total life expectancy with CI: 't' files ");
        strcpy(gplotlabel,"(");
-       for (k=1; k<=cptcoveff; k++){    /* For each covariate and each value */
+       for (k=1; k<=cptcovs; k++){    /* For each covariate k get corresponding value lv for combination k1 */
-         lv= decodtabm(k1,k,cptcoveff); /* Should be the covariate number corresponding to k1 combination */
+         fprintf(ficgp," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-         /* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 */
+         sprintf(gplotlabel+strlen(gplotlabel)," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-         /* decodtabm(1,2,4) = 1 because h=1  k=  1 (1) 1  1 */
+       /* for (k=1; k<=cptcoveff; k++){    /\* For each covariate and each value *\/ */
-         /* decodtabm(13,3,4)= 2 because h=13 k=  1  1 (2) 2 */
+       /*        /\* lv= decodtabm(k1,k,cptcoveff); /\\* Should be the covariate number corresponding to k1 combination *\\/ *\/ */
-         vlv= nbcode[Tvaraff[k]][lv];
+       /*        lv=codtabm(k1,TnsdVar[Tvaraff[k]]); */
-         fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv);
+       /*        /\* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 *\/ */
-         sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv);
+       /*        /\* 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 *\/ */
-       /* for(k=1; k <= ncovds; k++){ */
+       /*        /\* vlv= nbcode[Tvaraff[k]][lv]; *\/ */
-       for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
+       /*        vlv= nbcode[Tvaraff[k]][codtabm(k1,TnsdVar[Tvaraff[k]])]; */
-         printf(" V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+       /*        fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv); */
-         fprintf(ficgp," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+       /*        sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv); */
-         sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+       /* } */
+       /* /\* for(k=1; k <= ncovds; k++){ *\/ */
+       /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
+       /*        printf(" V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]); */
+       /*        fprintf(ficgp," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]); */
+       /*        sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]); */
        }
        strcpy(gplotlabel+strlen(gplotlabel),")");
        fprintf(ficgp,"\n#\n");
- Line 7772  void printinggnuplot(char fileresu[], ch
+ Line 10316  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 7795  void printinggnuplot(char fileresu[], ch
+ Line 10339  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 */
-   } /* k1 end 2 eme*/
+   /* } /\* k1 end 2 eme*\/ */
    /*3eme*/
-   for (k1=1; k1<= m ; k1 ++){
+   /* for (k1=1; k1<= m ; k1 ++){ */
      for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-       if(m != 1 && TKresult[nres]!= k1)
+       k1=TKresult[nres];
-         continue;
+       if(TKresult[nres]==0) k1=1; /* To be checked for noresult */
+       /* if(m != 1 && TKresult[nres]!= k1) */
+       /*        continue; */
-       for (cpt=1; cpt<= nlstate ; cpt ++) {
+       for (cpt=1; cpt<= nlstate ; cpt ++) { /* Fragile no verification of covariate values */
          fprintf(ficgp,"\n\n# 3d: Life expectancy with EXP_ files:  combination=%d state=%d",k1, cpt);
          strcpy(gplotlabel,"(");
-         for (k=1; k<=cptcoveff; k++){    /* For each covariate and each value */
+         for (k=1; k<=cptcovs; k++){    /* For each covariate k get corresponding value lv for combination k1 */
-           lv= decodtabm(k1,k,cptcoveff); /* Should be the covariate number corresponding to k1 combination */
+           fprintf(ficgp," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-           /* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 */
+           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-           /* decodtabm(1,2,4) = 1 because h=1  k=  1 (1) 1  1 */
+         /* for (k=1; k<=cptcoveff; k++){    /\* For each covariate and each value *\/ */
-           /* decodtabm(13,3,4)= 2 because h=13 k=  1  1 (2) 2 */
+         /*   /\* lv= decodtabm(k1,k,cptcoveff); /\\* Should be the covariate number corresponding to k1 combination *\\/ *\/ */
-           vlv= nbcode[Tvaraff[k]][lv];
+         /*   lv= codtabm(k1,TnsdVar[Tvaraff[k]]); /\* Should be the covariate value corresponding to combination k1 and covariate k *\/ */
-           fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv);
+         /*   /\* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 *\/ */
-           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv);
+         /*   /\* 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 *\/ */
-         for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
+         /*   /\* vlv= nbcode[Tvaraff[k]][lv]; *\/ */
-           fprintf(ficgp," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+         /*   vlv= nbcode[Tvaraff[k]][codtabm(k1,TnsdVar[Tvaraff[k]])]; */
-           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+         /*   fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv); */
-         }
+         /*   sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv); */
+         /* } */
+         /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
+         /*   fprintf(ficgp," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][resultmodel[nres][k4]]); */
+         /*   sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][resultmodel[nres][k4]]); */
+         }
          strcpy(gplotlabel+strlen(gplotlabel),")");
          fprintf(ficgp,"\n#\n");
          if(invalidvarcomb[k1]){
- Line 7856  plot [%.f:%.f] \"%s\" every :::%d::%d u
+ Line 10437  plot [%.f:%.f] \"%s\" every :::%d::%d u
        }
        fprintf(ficgp,"\nunset label;\n");
      } /* end nres */
-   } /* end kl 3eme */
+   /* } /\* end kl 3eme *\/ */
    /* 4eme */
    /* Survival functions (period) from state i in state j by initial state i */
-   for (k1=1; k1<=m; k1++){    /* For each covariate and each value */
+   /* for (k1=1; k1<=m; k1++){    /\* For each covariate and each value *\/ */
      for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-       if(m != 1 && TKresult[nres]!= k1)
+       k1=TKresult[nres];
-         continue;
+       if(TKresult[nres]==0) k1=1; /* To be checked for noresult */
+       /* if(m != 1 && TKresult[nres]!= k1) */
+       /*        continue; */
        for (cpt=1; cpt<=nlstate ; cpt ++) { /* For each life state cpt*/
          strcpy(gplotlabel,"(");
-         fprintf(ficgp,"\n#\n#\n# Survival functions in state j : 'LIJ_' files, cov=%d state=%d",k1, cpt);
+         fprintf(ficgp,"\n#\n#\n# Survival functions in state %d : 'LIJ_' files, cov=%d state=%d", cpt, k1, cpt);
-         for (k=1; k<=cptcoveff; k++){    /* For each covariate and each value */
+         for (k=1; k<=cptcovs; k++){    /* For each covariate k get corresponding value lv for combination k1 */
-           lv= decodtabm(k1,k,cptcoveff); /* Should be the covariate number corresponding to k1 combination */
+           fprintf(ficgp," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-           /* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 */
+           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-           /* decodtabm(1,2,4) = 1 because h=1  k=  1 (1) 1  1 */
+         /* for (k=1; k<=cptcoveff; k++){    /\* For each covariate and each value *\/ */
-           /* decodtabm(13,3,4)= 2 because h=13 k=  1  1 (2) 2 */
+         /*   lv=codtabm(k1,TnsdVar[Tvaraff[k]]); */
-           vlv= nbcode[Tvaraff[k]][lv];
+         /*   /\* lv= decodtabm(k1,k,cptcoveff); /\\* Should be the covariate number corresponding to k1 combination *\\/ *\/ */
-           fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv);
+         /*   /\* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 *\/ */
-           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv);
+         /*   /\* 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 *\/ */
-         for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
+         /*   /\* vlv= nbcode[Tvaraff[k]][lv]; *\/ */
-           fprintf(ficgp," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+         /*   vlv= nbcode[Tvaraff[k]][codtabm(k1,TnsdVar[Tvaraff[k]])]; */
-           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+         /*   fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv); */
+         /*   sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv); */
+         /* } */
+         /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
+         /*   fprintf(ficgp," V%d=%f ",Tvqresult[nres][resultmodel[nres][k4]],Tqresult[nres][resultmodel[nres][k4]]); */
+         /*   sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][resultmodel[nres][k4]],Tqresult[nres][resultmodel[nres][k4]]); */
          }
          strcpy(gplotlabel+strlen(gplotlabel),")");
          fprintf(ficgp,"\n#\n");
- Line 7907  set ter svg size 640, 480\nunset log y\n
+ Line 10495  set ter svg size 640, 480\nunset log y\n
          fprintf(ficgp,"\nset out; unset label;\n");
        } /* end cpt state*/
      } /* end nres */
-   } /* end covariate k1 */
+   /* } /\* end covariate k1 *\/   */
  /* 5eme */
    /* Survival functions (period) from state i in state j by final state j */
-   for (k1=1; k1<= m ; k1++){ /* For each covariate combination if any */
+   /* for (k1=1; k1<= m ; k1++){ /\* For each covariate combination if any *\/ */
      for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-       if(m != 1 && TKresult[nres]!= k1)
+       k1=TKresult[nres];
-         continue;
+       if(TKresult[nres]==0) k1=1; /* To be checked for noresult */
+       /* if(m != 1 && TKresult[nres]!= k1) */
+       /*        continue; */
        for (cpt=1; cpt<=nlstate ; cpt ++) { /* For each inital state  */
          strcpy(gplotlabel,"(");
          fprintf(ficgp,"\n#\n#\n# Survival functions in state j and all livestates from state i by final state j: 'lij' files, cov=%d state=%d",k1, cpt);
-         for (k=1; k<=cptcoveff; k++){    /* For each covariate and each value */
+         for (k=1; k<=cptcovs; k++){    /* For each covariate k get corresponding value lv for combination k1 */
-           lv= decodtabm(k1,k,cptcoveff); /* Should be the covariate number corresponding to k1 combination */
+           fprintf(ficgp," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-           /* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 */
+           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-           /* decodtabm(1,2,4) = 1 because h=1  k=  1 (1) 1  1 */
+         /* for (k=1; k<=cptcoveff; k++){    /\* For each covariate and each value *\/ */
-           /* decodtabm(13,3,4)= 2 because h=13 k=  1  1 (2) 2 */
+         /*   lv=codtabm(k1,TnsdVar[Tvaraff[k]]); */
-           vlv= nbcode[Tvaraff[k]][lv];
+         /*   /\* lv= decodtabm(k1,k,cptcoveff); /\\* Should be the covariate number corresponding to k1 combination *\\/ *\/ */
-           fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv);
+         /*   /\* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 *\/ */
-           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv);
+         /*   /\* 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 *\/ */
-         for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
+         /*   /\* vlv= nbcode[Tvaraff[k]][lv]; *\/ */
-           fprintf(ficgp," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+         /*   vlv= nbcode[Tvaraff[k]][codtabm(k1,TnsdVar[Tvaraff[k]])]; */
-           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+         /*   fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv); */
+         /*   sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv); */
+         /* } */
+         /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
+         /*   fprintf(ficgp," V%d=%f ",Tvqresult[nres][resultmodel[nres][k4]],Tqresult[nres][resultmodel[nres][k4]]); */
+         /*   sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][resultmodel[nres][k4]],Tqresult[nres][resultmodel[nres][k4]]); */
          }
          strcpy(gplotlabel+strlen(gplotlabel),")");
          fprintf(ficgp,"\n#\n");
- Line 7965  set ter svg size 640, 480\nunset log y\n
+ Line 10560  set ter svg size 640, 480\nunset log y\n
          }
          fprintf(ficgp,"\nset out; unset label;\n");
        } /* end cpt state*/
-     } /* end covariate */
+     /* } /\* end covariate *\/   */
    } /* end nres */
  /* 6eme */
    /* CV preval stable (period) for each covariate */
-   for (k1=1; k1<= m ; k1 ++) /* For each covariate combination if any */
+   /* for (k1=1; k1<= m ; k1 ++) /\* For each covariate combination if any *\/ */
    for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-     if(m != 1 && TKresult[nres]!= k1)
+      k1=TKresult[nres];
-       continue;
+      if(TKresult[nres]==0) k1=1; /* To be checked for noresult */
+      /* if(m != 1 && TKresult[nres]!= k1) */
+      /*  continue; */
      for (cpt=1; cpt<=nlstate ; cpt ++) { /* For each life state of arrival */
        strcpy(gplotlabel,"(");
        fprintf(ficgp,"\n#\n#\n#CV preval stable (forward): 'pij' files, covariatecombination#=%d state=%d",k1, cpt);
-       for (k=1; k<=cptcoveff; k++){    /* For each covariate and each value */
+       for (k=1; k<=cptcovs; k++){    /* For each covariate k get corresponding value lv for combination k1 */
-         lv= decodtabm(k1,k,cptcoveff); /* Should be the covariate number corresponding to k1 combination */
+         fprintf(ficgp," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-         /* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 */
+         sprintf(gplotlabel+strlen(gplotlabel)," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-         /* decodtabm(1,2,4) = 1 because h=1  k=  1 (1) 1  1 */
+       /* for (k=1; k<=cptcoveff; k++){    /\* For each covariate and each value *\/ */
-         /* decodtabm(13,3,4)= 2 because h=13 k=  1  1 (2) 2 */
+       /*        /\* lv= decodtabm(k1,k,cptcoveff); /\\* Should be the covariate number corresponding to k1 combination *\\/ *\/ */
-         vlv= nbcode[Tvaraff[k]][lv];
+       /*        lv=codtabm(k1,TnsdVar[Tvaraff[k]]); */
-         fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv);
+       /*        /\* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 *\/ */
-         sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv);
+       /*        /\* 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 *\/ */
-       for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
+       /*        /\* vlv= nbcode[Tvaraff[k]][lv]; *\/ */
-         fprintf(ficgp," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+       /*        vlv= nbcode[Tvaraff[k]][codtabm(k1,TnsdVar[Tvaraff[k]])]; */
-         sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+       /*        fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv); */
+       /*        sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv); */
+       /* } */
+       /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
+       /*        fprintf(ficgp," V%d=%f ",Tvqresult[nres][resultmodel[nres][k4]],Tqresult[nres][resultmodel[nres][k4]]); */
+       /*        sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][resultmodel[nres][k4]],Tqresult[nres][resultmodel[nres][k4]]); */
        }
        strcpy(gplotlabel+strlen(gplotlabel),")");
        fprintf(ficgp,"\n#\n");
- Line 8021  set ter svg size 640, 480\nunset log y\n
+ Line 10623  set ter svg size 640, 480\nunset log y\n
  /* 7eme */
    if(prevbcast == 1){
      /* CV backward prevalence  for each covariate */
-     for (k1=1; k1<= m ; k1 ++) /* For each covariate combination if any */
+     /* for (k1=1; k1<= m ; k1 ++) /\* For each covariate combination if any *\/ */
      for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-       if(m != 1 && TKresult[nres]!= k1)
+       k1=TKresult[nres];
-         continue;
+       if(TKresult[nres]==0) k1=1; /* To be checked for noresult */
+       /* if(m != 1 && TKresult[nres]!= k1) */
+       /*        continue; */
        for (cpt=1; cpt<=nlstate ; cpt ++) { /* For each life origin state */
          strcpy(gplotlabel,"(");
          fprintf(ficgp,"\n#\n#\n#CV Backward stable prevalence: 'pijb' files, covariatecombination#=%d state=%d",k1, cpt);
-         for (k=1; k<=cptcoveff; k++){    /* For each covariate and each value */
+         for (k=1; k<=cptcovs; k++){    /* For each covariate k get corresponding value lv for combination k1 */
-           lv= decodtabm(k1,k,cptcoveff); /* Should be the covariate number corresponding to k1 combination */
+           fprintf(ficgp," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-           /* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 */
+           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-           /* decodtabm(1,2,4) = 1 because h=1  k=  1 (1) 1  1 */
+         /* for (k=1; k<=cptcoveff; k++){    /\* For each covariate and each value *\/ */
-           /* decodtabm(13,3,4)= 2 because h=13 k=  1  1 (2) 2 */
+         /*   /\* lv= decodtabm(k1,k,cptcoveff); /\\* Should be the covariate number corresponding to k1 combination *\\/ *\/ */
-           vlv= nbcode[Tvaraff[k]][lv];
+         /*   lv=codtabm(k1,TnsdVar[Tvaraff[k]]); */
-           fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv);
+         /*   /\* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 *\/ */
-           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv);
+         /*   /\* 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 *\/ */
-         for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
+         /*   /\* vlv= nbcode[Tvaraff[k]][lv]; *\/ */
-           fprintf(ficgp," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+         /*   vlv= nbcode[Tvaraff[k]][codtabm(k1,TnsdVar[Tvaraff[k]])]; */
-           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+         /*   fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv); */
+         /*   sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv); */
+         /* } */
+         /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
+         /*   fprintf(ficgp," V%d=%f ",Tvqresult[nres][resultmodel[nres][k4]],Tqresult[nres][resultmodel[nres][k4]]); */
+         /*   sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][resultmodel[nres][k4]],Tqresult[nres][resultmodel[nres][k4]]); */
          }
          strcpy(gplotlabel+strlen(gplotlabel),")");
          fprintf(ficgp,"\n#\n");
- Line 8077  set ter svg size 640, 480\nunset log y\n
+ Line 10686  set ter svg size 640, 480\nunset log y\n
    if(prevfcast==1){
      /* Projection from cross-sectional to forward stable (period) prevalence for each covariate */
-     for (k1=1; k1<= m ; k1 ++) /* For each covariate combination if any */
+     /* for (k1=1; k1<= m ; k1 ++) /\* For each covariate combination if any *\/ */
      for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-       if(m != 1 && TKresult[nres]!= k1)
+       k1=TKresult[nres];
-         continue;
+       if(TKresult[nres]==0) k1=1; /* To be checked for noresult */
+       /* if(m != 1 && TKresult[nres]!= k1) */
+       /*        continue; */
        for (cpt=1; cpt<=nlstate ; cpt ++) { /* For each life state */
          strcpy(gplotlabel,"(");
          fprintf(ficgp,"\n#\n#\n#Projection of prevalence to forward stable prevalence (period): 'PROJ_' files, covariatecombination#=%d state=%d",k1, cpt);
-         for (k=1; k<=cptcoveff; k++){    /* For each correspondig covariate value  */
+         for (k=1; k<=cptcovs; k++){    /* For each covariate k get corresponding value lv for combination k1 */
-           lv= decodtabm(k1,k,cptcoveff); /* Should be the covariate value corresponding to k1 combination and kth covariate */
+           fprintf(ficgp," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-           /* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 */
+           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-           /* decodtabm(1,2,4) = 1 because h=1  k=  1 (1) 1  1 */
+         /* for (k=1; k<=cptcoveff; k++){    /\* For each correspondig covariate value  *\/ */
-           /* decodtabm(13,3,4)= 2 because h=13 k=  1  1 (2) 2 */
+         /*   /\* lv= decodtabm(k1,k,cptcoveff); /\\* Should be the covariate value corresponding to k1 combination and kth covariate *\\/ *\/ */
-           vlv= nbcode[Tvaraff[k]][lv];
+         /*   lv=codtabm(k1,TnsdVar[Tvaraff[k]]); */
-           fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv);
+         /*   /\* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 *\/ */
-           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv);
+         /*   /\* 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 *\/ */
-         for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
+         /*   /\* vlv= nbcode[Tvaraff[k]][lv]; *\/ */
-           fprintf(ficgp," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+         /*   vlv= nbcode[Tvaraff[k]][codtabm(k1,TnsdVar[Tvaraff[k]])]; */
-           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+         /*   fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv); */
+         /*   sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv); */
+         /* } */
+         /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
+         /*   fprintf(ficgp," V%d=%f ",Tvqresult[nres][resultmodel[nres][k4]],Tqresult[nres][resultmodel[nres][k4]]); */
+         /*   sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][resultmodel[nres][k4]],Tqresult[nres][resultmodel[nres][k4]]); */
          }
          strcpy(gplotlabel+strlen(gplotlabel),")");
          fprintf(ficgp,"\n#\n");
- Line 8150  set ter svg size 640, 480\nunset log y\n
+ Line 10766  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= decodtabm(k1,k,cptcoveff); /\* Should be the covariate value corresponding to combination k1 and covariate 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]][lv]; /\* Value of the modality of 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 8190  set ter svg size 640, 480\nunset log y\n
+ Line 10812  set ter svg size 640, 480\nunset log y\n
    if(prevbcast==1){
      /* Back projection from cross-sectional to stable (mixed) for each covariate */
-     for (k1=1; k1<= m ; k1 ++) /* For each covariate combination if any */
+     /* for (k1=1; k1<= m ; k1 ++) /\* For each covariate combination if any *\/ */
      for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-       if(m != 1 && TKresult[nres]!= k1)
+      k1=TKresult[nres];
-         continue;
+      if(TKresult[nres]==0) k1=1; /* To be checked for noresult */
+        /* if(m != 1 && TKresult[nres]!= k1) */
+        /*       continue; */
        for (cpt=1; cpt<=nlstate ; cpt ++) { /* For each life state */
          strcpy(gplotlabel,"(");
          fprintf(ficgp,"\n#\n#\n#Back projection of prevalence to stable (mixed) back prevalence: 'BPROJ_' files, covariatecombination#=%d originstate=%d",k1, cpt);
-         for (k=1; k<=cptcoveff; k++){    /* For each correspondig covariate value  */
+         for (k=1; k<=cptcovs; k++){    /* For each covariate k get corresponding value lv for combination k1 */
-           lv= decodtabm(k1,k,cptcoveff); /* Should be the covariate value corresponding to k1 combination and kth covariate */
+           fprintf(ficgp," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-           /* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 */
+           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-           /* decodtabm(1,2,4) = 1 because h=1  k=  1 (1) 1  1 */
+         /* for (k=1; k<=cptcoveff; k++){    /\* For each correspondig covariate value  *\/ */
-           /* decodtabm(13,3,4)= 2 because h=13 k=  1  1 (2) 2 */
+         /*   /\* lv= decodtabm(k1,k,cptcoveff); /\\* Should be the covariate value corresponding to k1 combination and kth covariate *\\/ *\/ */
-           vlv= nbcode[Tvaraff[k]][lv];
+         /*   lv= codtabm(k1,TnsdVar[Tvaraff[k]]); /\* Should be the covariate value corresponding to combination k1 and covariate k *\/ */
-           fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv);
+         /*   /\* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 *\/ */
-           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv);
+         /*   /\* 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 *\/ */
-         for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
+         /*   /\* vlv= nbcode[Tvaraff[k]][lv]; *\/ */
-           fprintf(ficgp," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+         /*   vlv= nbcode[Tvaraff[k]][codtabm(k1,TnsdVar[Tvaraff[k]])]; */
-           sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+         /*   fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv); */
+         /*   sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv); */
+         /* } */
+         /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
+         /*   fprintf(ficgp," V%d=%f ",Tvqresult[nres][resultmodel[nres][k4]],Tqresult[nres][resultmodel[nres][k4]]); */
+         /*   sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][resultmodel[nres][k4]],Tqresult[nres][resultmodel[nres][k4]]); */
          }
          strcpy(gplotlabel+strlen(gplotlabel),")");
          fprintf(ficgp,"\n#\n");
- Line 8236  set ter svg size 640, 480\nunset log y\n
+ Line 10865  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 8263  set ter svg size 640, 480\nunset log y\n
+ Line 10893  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<=cptcovs; k++){    /* For each covariate k of the resultline, get corresponding value lv for combination k1 */
-               lv= decodtabm(k1,k,cptcoveff); /* Should be the covariate value corresponding to combination k1 and covariate k */
+               if(Dummy[modelresult[nres][k]]==0){  /* To be verified */
-               /* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 */
+                 /* for (k=1; k<=cptcoveff; k++){    /\* For each covariate writing the chain of conditions *\/ */
-               /* decodtabm(1,2,4) = 1 because h=1  k=  1 (1) 1  1 */
+                 /* lv= decodtabm(k1,k,cptcoveff); /\* Should be the covariate value corresponding to combination k1 and covariate k *\/ */
-               /* decodtabm(13,3,4)= 2 because h=13 k=  1  1 (2) 2 */
+                 /* lv= codtabm(k1,TnsdVar[Tvaraff[k]]); /\* Should be the covariate value corresponding to combination k1 and covariate k *\/ */
-               vlv= nbcode[Tvaraff[k]][lv]; /* Value of the modality of Tvaraff[k] */
+                 lv=Tvresult[nres][k];
-               kl++;
+                 vlv=TinvDoQresult[nres][Tvresult[nres][k]];
-               sprintf(gplotcondition+strlen(gplotcondition),"$%d==%d && $%d==%d " ,kl,Tvaraff[k], kl+1, nbcode[Tvaraff[k]][lv]);
+                 /* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 */
-               kl++;
+                 /* decodtabm(1,2,4) = 1 because h=1  k=  1 (1) 1  1 */
-               if(k <cptcoveff && cptcoveff>1)
+                 /* decodtabm(13,3,4)= 2 because h=13 k=  1  1 (2) 2 */
-                 sprintf(gplotcondition+strlen(gplotcondition)," && ");
+                 /* vlv= nbcode[Tvaraff[k]][lv]; /\* Value of the modality of 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==%lg " ,kl,Tvresult[nres][k], kl+1,TinvDoQresult[nres][Tvresult[nres][k]]);
+                 kl++;
+                 if(k <cptcovs && cptcovs>1)
+                   sprintf(gplotcondition+strlen(gplotcondition)," && ");
+               }
              }
              strcpy(gplotcondition+strlen(gplotcondition),")");
              /* kl=6+(cpt-1)*(nlstate+1)+1+(i-1); /\* 6+(1-1)*(2+1)+1+(1-1)=7, 6+(2-1)(2+1)+1+(1-1)=10 *\/ */
- Line 8338  set ter svg size 640, 480\nunset log y\n
+ Line 10976  set ter svg size 640, 480\nunset log y\n
    fprintf(ficgp,"#\n");
    for(ng=1; ng<=3;ng++){ /* Number of graphics: first is logit, 2nd is probabilities, third is incidences per year*/
      fprintf(ficgp,"#Number of graphics: first is logit, 2nd is probabilities, third is incidences per year\n");
-     fprintf(ficgp,"#model=%s \n",model);
+     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 *\/ */
-     for(k1=1; k1 <=m; k1++)  /* For each combination of covariate */
+     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 */
-       if(m != 1 && TKresult[nres]!= k1)
+      /* k1=nres; */
-         continue;
+       k1=TKresult[nres];
-       fprintf(ficgp,"\n\n# Combination of dummy  k1=%d which is ",k1);
+       if(TKresult[nres]==0) k1=1; /* To be checked for noresult */
+       fprintf(ficgp,"\n\n# Resultline k1=%d ",k1);
        strcpy(gplotlabel,"(");
        /*sprintf(gplotlabel+strlen(gplotlabel)," Dummy combination %d ",k1);*/
-       for (k=1; k<=cptcoveff; k++){    /* For each correspondig covariate value  */
+       for (k=1; k<=cptcovs; k++){  /**< cptcovs number of SIMPLE covariates in the model V2+V1 =2 (dummy or quantit or time varying) */
-         lv= decodtabm(k1,k,cptcoveff); /* Should be the covariate value corresponding to k1 combination and kth covariate */
+         /* for each resultline nres, and position k, Tvresult[nres][k] gives the name of the variable and
-         /* decodtabm(1,1,4) = 1 because h=1  k= (1) 1  1  1 */
+            TinvDoQresult[nres][Tvresult[nres][k]] gives its value double or integer) */
-         /* decodtabm(1,2,4) = 1 because h=1  k=  1 (1) 1  1 */
+         fprintf(ficgp," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-         /* decodtabm(13,3,4)= 2 because h=13 k=  1  1 (2) 2 */
+         sprintf(gplotlabel+strlen(gplotlabel)," V%d=%lg ",Tvresult[nres][k],TinvDoQresult[nres][Tvresult[nres][k]]);
-         vlv= nbcode[Tvaraff[k]][lv];
+       }
-         fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv);
+       /* if(m != 1 && TKresult[nres]!= k1) */
-         sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv);
+       /*        continue; */
-       }
+       /* fprintf(ficgp,"\n\n# Combination of dummy  k1=%d which is ",k1); */
-       for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
+       /* strcpy(gplotlabel,"("); */
-         fprintf(ficgp," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+       /* /\*sprintf(gplotlabel+strlen(gplotlabel)," Dummy combination %d ",k1);*\/ */
-         sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+       /* for (k=1; k<=cptcoveff; k++){    /\* For each correspondig covariate value  *\/ */
-       }
+       /*        /\* lv= decodtabm(k1,k,cptcoveff); /\\* Should be the covariate value corresponding to k1 combination and kth covariate *\\/ *\/ */
+       /*        lv= codtabm(k1,TnsdVar[Tvaraff[k]]); /\* Should be the covariate value corresponding to combination k1 and covariate 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]; *\/ */
+       /*        vlv= nbcode[Tvaraff[k]][codtabm(k1,TnsdVar[Tvaraff[k]])]; */
+       /*        fprintf(ficgp," V%d=%d ",Tvaraff[k],vlv); */
+       /*        sprintf(gplotlabel+strlen(gplotlabel)," V%d=%d ",Tvaraff[k],vlv); */
+       /* } */
+       /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
+       /*        fprintf(ficgp," V%d=%f ",Tvqresult[nres][resultmodel[nres][k4]],Tqresult[nres][resultmodel[nres][k4]]); */
+       /*        sprintf(gplotlabel+strlen(gplotlabel)," V%d=%f ",Tvqresult[nres][resultmodel[nres][k4]],Tqresult[nres][resultmodel[nres][k4]]); */
+       /* }       */
        strcpy(gplotlabel+strlen(gplotlabel),")");
        fprintf(ficgp,"\n#\n");
        fprintf(ficgp,"\nset out \"%s_%d-%d-%d.svg\" ",subdirf2(optionfilefiname,"PE_"),k1,ng,nres);
- Line 8410  set ter svg size 640, 480\nunset log y\n
+ Line 11063  set ter svg size 640, 480\nunset log y\n
              /* for(j=3; j <=ncovmodel-nagesqr; j++) { */
              for(j=1; j <=cptcovt; j++) { /* For each covariate of the simplified model */
                /* printf("Tage[%d]=%d, j=%d\n", ij, Tage[ij], j); */
-               if(cptcovage >0){ /* V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1, 2 V5 and V1 */
+               switch(Typevar[j]){
-                 if(j==Tage[ij]) { /* Product by age  To be looked at!!*//* Bug valgrind */
+               case 1:
-                   if(ij <=cptcovage) { /* V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1, 2 V5 and V1 */
+                 if(cptcovage >0){ /* V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1, 2 V5 and V1 */
-                     if(DummyV[j]==0){/* Bug valgrind */
+                   if(j==Tage[ij]) { /* Product by age  To be looked at!!*//* Bug valgrind */
-                       fprintf(ficgp,"+p%d*%d*x",i+j+2+nagesqr-1,Tinvresult[nres][Tvar[j]]);;
+                     if(ij <=cptcovage) { /* V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1, 2 V5 and V1 */
-                     }else{ /* quantitative */
+                       if(DummyV[j]==0){/* Bug valgrind */
-                       fprintf(ficgp,"+p%d*%f*x",i+j+2+nagesqr-1,Tqinvresult[nres][Tvar[j]]); /* Tqinvresult in decoderesult */
+                         fprintf(ficgp,"+p%d*%d*x",i+j+2+nagesqr-1,Tinvresult[nres][Tvar[j]]);;
-                       /* fprintf(ficgp,"+p%d*%d*x",i+j+nagesqr-1,nbcode[Tvar[j-2]][codtabm(k1,Tvar[j-2])]); */
+                       }else{ /* quantitative */
+                         fprintf(ficgp,"+p%d*%f*x",i+j+2+nagesqr-1,Tqinvresult[nres][Tvar[j]]); /* Tqinvresult in decoderesult */
+                         /* fprintf(ficgp,"+p%d*%d*x",i+j+nagesqr-1,nbcode[Tvar[j-2]][codtabm(k1,Tvar[j-2])]); */
+                       }
+                       ij++;
                      }
-                     ij++;
                    }
                  }
-               }else if(cptcovprod >0){
+                 break;
-                 if(j==Tprod[ijp]) { /* */
+               case 2:
-                   /* printf("Tprod[%d]=%d, j=%d\n", ij, Tprod[ijp], j); */
+                 if(cptcovprod >0){
-                   if(ijp <=cptcovprod) { /* Product */
+                   if(j==Tprod[ijp]) { /* */
-                     if(DummyV[Tvard[ijp][1]]==0){/* Vn is dummy */
+                     /* printf("Tprod[%d]=%d, j=%d\n", ij, Tprod[ijp], j); */
-                       if(DummyV[Tvard[ijp][2]]==0){/* Vn and Vm are dummy */
+                     if(ijp <=cptcovprod) { /* Product */
-                         /* 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)]); */
+                       if(DummyV[Tvard[ijp][1]]==0){/* Vn is dummy */
-                         fprintf(ficgp,"+p%d*%d*%d",i+j+2+nagesqr-1,Tinvresult[nres][Tvard[ijp][1]],Tinvresult[nres][Tvard[ijp][2]]);
+                         if(DummyV[Tvard[ijp][2]]==0){/* Vn and Vm are dummy */
-                       }else{ /* Vn is dummy and Vm is quanti */
+                           /* 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*%f",i+j+2+nagesqr-1,nbcode[Tvard[ijp][1]][codtabm(k1,j)],Tqinvresult[nres][Tvard[ijp][2]]); */
+                           fprintf(ficgp,"+p%d*%d*%d",i+j+2+nagesqr-1,Tinvresult[nres][Tvard[ijp][1]],Tinvresult[nres][Tvard[ijp][2]]);
-                         fprintf(ficgp,"+p%d*%d*%f",i+j+2+nagesqr-1,Tinvresult[nres][Tvard[ijp][1]],Tqinvresult[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",i+j+2+nagesqr-1,Tinvresult[nres][Tvard[ijp][1]],Tqinvresult[nres][Tvard[ijp][2]]);
+                         }
+                       }else{ /* Vn*Vm Vn is quanti */
+                         if(DummyV[Tvard[ijp][2]]==0){
+                           fprintf(ficgp,"+p%d*%d*%f",i+j+2+nagesqr-1,Tinvresult[nres][Tvard[ijp][2]],Tqinvresult[nres][Tvard[ijp][1]]);
+                         }else{ /* Both quanti */
+                           fprintf(ficgp,"+p%d*%f*%f",i+j+2+nagesqr-1,Tqinvresult[nres][Tvard[ijp][1]],Tqinvresult[nres][Tvard[ijp][2]]);
+                         }
                        }
-                     }else{ /* Vn*Vm Vn is quanti */
+                       ijp++;
-                       if(DummyV[Tvard[ijp][2]]==0){
+                     }
-                         fprintf(ficgp,"+p%d*%d*%f",i+j+2+nagesqr-1,Tinvresult[nres][Tvard[ijp][2]],Tqinvresult[nres][Tvard[ijp][1]]);
+                   } /* end Tprod */
-                       }else{ /* Both quanti */
+                 }
-                         fprintf(ficgp,"+p%d*%f*%f",i+j+2+nagesqr-1,Tqinvresult[nres][Tvard[ijp][1]],Tqinvresult[nres][Tvard[ijp][2]]);
+                 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++;
                      }
-                     ijp++;
+                     /* } */ /* end Tprod */
-                   }
+                 }
-                 } /* end Tprod */
+                 break;
-               } else{  /* simple covariate */
+               case 0:
+                 /* simple covariate */
                  /* fprintf(ficgp,"+p%d*%d",i+j+2+nagesqr-1,nbcode[Tvar[j]][codtabm(k1,j)]); /\* Valgrind bug nbcode *\/ */
                  if(Dummy[j]==0){
                    fprintf(ficgp,"+p%d*%d",i+j+2+nagesqr-1,Tinvresult[nres][Tvar[j]]); /*  */
- Line 8452  set ter svg size 640, 480\nunset log y\n
+ Line 11138  set ter svg size 640, 480\nunset log y\n
                    fprintf(ficgp,"+p%d*%f",i+j+2+nagesqr-1,Tqinvresult[nres][Tvar[j]]); /* */
                    /* fprintf(ficgp,"+p%d*%d*x",i+j+nagesqr-1,nbcode[Tvar[j-2]][codtabm(k1,Tvar[j-2])]); */
                  }
-               } /* end simple */
+                /* end simple */
+                 break;
+               default:
+                 break;
+               } /* end switch */
              } /* end j */
-           }else{
+           }else{ /* k=k2 */
-             i=i-ncovmodel;
+             if(ng !=1 ){ /* For logit formula of log p11 is more difficult to get */
-             if(ng !=1 ) /* For logit formula of log p11 is more difficult to get */
+               fprintf(ficgp," (1.");i=i-ncovmodel;
-               fprintf(ficgp," (1.");
+             }else
+               i=i-ncovmodel;
            }
            if(ng != 1){
- Line 8470  set ter svg size 640, 480\nunset log y\n
+ Line 11161  set ter svg size 640, 480\nunset log y\n
                  fprintf(ficgp,"+exp(p%d+p%d*x+p%d*x*x",k3+(cpt-1)*ncovmodel,k3+(cpt-1)*ncovmodel+1,k3+(cpt-1)*ncovmodel+1+nagesqr);
                ij=1;
-               for(j=3; j <=ncovmodel-nagesqr; j++){
+               ijp=1;
-                  if(cptcovage >0){
+               /* for(j=3; j <=ncovmodel-nagesqr; j++){ */
-                    if((j-2)==Tage[ij]) { /* Bug valgrind */
+               for(j=1; j <=cptcovt; j++) { /* For each covariate of the simplified model */
-                      if(ij <=cptcovage) { /* Bug valgrind */
+                 switch(Typevar[j]){
-                        fprintf(ficgp,"+p%d*%d*x",k3+(cpt-1)*ncovmodel+1+j-2+nagesqr,nbcode[Tvar[j-2]][codtabm(k1,j-2)]);
+                 case 1:
-                        /* fprintf(ficgp,"+p%d*%d*x",k3+(cpt-1)*ncovmodel+1+j-2+nagesqr,nbcode[Tvar[j-2]][codtabm(k1,Tvar[j-2])]); */
+                   if(cptcovage >0){
-                        ij++;
+                     if(j==Tage[ij]) { /* Bug valgrind */
-                      }
+                       if(ij <=cptcovage) { /* Bug valgrind */
-                    }
+                         if(DummyV[j]==0){/* Bug valgrind */
-                  }else
+                           /* fprintf(ficgp,"+p%d*%d*x",k3+(cpt-1)*ncovmodel+1+j-2+nagesqr,nbcode[Tvar[j-2]][codtabm(k1,j-2)]); */
-                    fprintf(ficgp,"+p%d*%d",k3+(cpt-1)*ncovmodel+1+j-2+nagesqr,nbcode[Tvar[j-2]][codtabm(k1,j-2)]);/* Valgrind bug nbcode */
+                           /* fprintf(ficgp,"+p%d*%d*x",k3+(cpt-1)*ncovmodel+1+j+nagesqr,nbcode[Tvar[j]][codtabm(k1,j)]); */
+                           fprintf(ficgp,"+p%d*%d*x",k3+(cpt-1)*ncovmodel+1+j+nagesqr,Tinvresult[nres][Tvar[j]]);
+                           /* fprintf(ficgp,"+p%d*%d*x",i+j+2+nagesqr-1,Tinvresult[nres][Tvar[j]]);; */
+                           /* fprintf(ficgp,"+p%d*%d*x",k3+(cpt-1)*ncovmodel+1+j-2+nagesqr,nbcode[Tvar[j-2]][codtabm(k1,Tvar[j-2])]); */
+                         }else{ /* quantitative */
+                           /* fprintf(ficgp,"+p%d*%f*x",i+j+2+nagesqr-1,Tqinvresult[nres][Tvar[j]]); /\* Tqinvresult in decoderesult *\/ */
+                           fprintf(ficgp,"+p%d*%f*x",k3+(cpt-1)*ncovmodel+1+j+nagesqr,Tqinvresult[nres][Tvar[j]]); /* Tqinvresult in decoderesult */
+                           /* fprintf(ficgp,"+p%d*%f*x",i+j+2+nagesqr-1,Tqinvresult[nres][Tvar[j]]); /\* Tqinvresult in decoderesult *\/ */
+                           /* fprintf(ficgp,"+p%d*%d*x",i+j+nagesqr-1,nbcode[Tvar[j-2]][codtabm(k1,Tvar[j-2])]); */
+                         }
+                         ij++;
+                       }
+                     }
+                   }
+                   break;
+                 case 2:
+                   if(cptcovprod >0){
+                     if(j==Tprod[ijp]) { /* */
+                       /* printf("Tprod[%d]=%d, j=%d\n", ij, Tprod[ijp], j); */
+                       if(ijp <=cptcovprod) { /* Product */
+                         if(DummyV[Tvard[ijp][1]]==0){/* Vn is dummy */
+                           if(DummyV[Tvard[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",k3+(cpt-1)*ncovmodel+1+j+nagesqr,Tinvresult[nres][Tvard[ijp][1]],Tinvresult[nres][Tvard[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",k3+(cpt-1)*ncovmodel+1+j+nagesqr,Tinvresult[nres][Tvard[ijp][1]],Tqinvresult[nres][Tvard[ijp][2]]);
+                             /* fprintf(ficgp,"+p%d*%d*%f",i+j+2+nagesqr-1,Tinvresult[nres][Tvard[ijp][1]],Tqinvresult[nres][Tvard[ijp][2]]); */
+                           }
+                         }else{ /* Vn*Vm Vn is quanti */
+                           if(DummyV[Tvard[ijp][2]]==0){
+                             fprintf(ficgp,"+p%d*%d*%f",k3+(cpt-1)*ncovmodel+1+j+nagesqr,Tinvresult[nres][Tvard[ijp][2]],Tqinvresult[nres][Tvard[ijp][1]]);
+                             /* fprintf(ficgp,"+p%d*%d*%f",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][Tvard[ijp][1]],Tqinvresult[nres][Tvard[ijp][2]]);
+                             /* fprintf(ficgp,"+p%d*%f*%f",i+j+2+nagesqr-1,Tqinvresult[nres][Tvard[ijp][1]],Tqinvresult[nres][Tvard[ijp][2]]); */
+                           }
+                         }
+                         ijp++;
+                       }
+                     } /* 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 *\/ */
+                   if(Dummy[j]==0){
+                     /* fprintf(ficgp,"+p%d*%d",i+j+2+nagesqr-1,Tinvresult[nres][Tvar[j]]); /\*  *\/ */
+                     fprintf(ficgp,"+p%d*%d",k3+(cpt-1)*ncovmodel+1+j+nagesqr,Tinvresult[nres][Tvar[j]]); /*  */
+                     /* fprintf(ficgp,"+p%d*%d",i+j+2+nagesqr-1,Tinvresult[nres][Tvar[j]]); /\*  *\/ */
+                   }else{ /* quantitative */
+                     fprintf(ficgp,"+p%d*%f",k3+(cpt-1)*ncovmodel+1+j+nagesqr,Tqinvresult[nres][Tvar[j]]); /* */
+                     /* fprintf(ficgp,"+p%d*%f",i+j+2+nagesqr-1,Tqinvresult[nres][Tvar[j]]); /\* *\/ */
+                     /* fprintf(ficgp,"+p%d*%d*x",i+j+nagesqr-1,nbcode[Tvar[j-2]][codtabm(k1,Tvar[j-2])]); */
+                   }
+                   /* end simple */
+                   /* fprintf(ficgp,"+p%d*%d",k3+(cpt-1)*ncovmodel+1+j-2+nagesqr,nbcode[Tvar[j-2]][codtabm(k1,j-2)]);/\* Valgrind bug nbcode *\/ */
+                   break;
+                 default:
+                   break;
+                 } /* end switch */
                }
                fprintf(ficgp,")");
              }
- Line 8489  set ter svg size 640, 480\nunset log y\n
+ Line 11270  set ter svg size 640, 480\nunset log y\n
                fprintf(ficgp," w l lw 2 lt (%d*%d+%d)%%%d+1 dt %d t \"p%d%d\" ", nlstate+ndeath, k2, k, nlstate+ndeath, k2, k2,k);
              else /* ng= 3 */
                fprintf(ficgp," w l lw 2 lt (%d*%d+%d)%%%d+1 dt %d t \"i%d%d\" ",  nlstate+ndeath, k2, k, nlstate+ndeath, k2, k2,k);
            }else{ /* end ng <> 1 */
              if( k !=k2) /* logit p11 is hard to draw */
                fprintf(ficgp," w l lw 2 lt (%d*%d+%d)%%%d+1 dt %d t \"logit(p%d%d)\" ",  nlstate+ndeath, k2, k, nlstate+ndeath, k2, k2,k);
            }
- Line 8502  set ter svg size 640, 480\nunset log y\n
+ Line 11283  set ter svg size 640, 480\nunset log y\n
        } /* end k2 */
        /* fprintf(ficgp,"\n set out; unset label;set key default;\n"); */
        fprintf(ficgp,"\n set out; unset title;set key default;\n");
-     } /* end k1 */
+     } /* end resultline */
    } /* end ng */
    /* avoid: */
    fflush(ficgp);
- Line 8760  void prevforecast(char fileres[], double
+ Line 11541  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 8816  void prevforecast(char fileres[], double
+ Line 11597  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++){
+     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,j)]);
+       /* for(j=1;j<=cptcoveff;j++) { */
-     }
+     /*   /\* fprintf(ficresf," V%d (=) %d",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,Tvaraff[j])]); *\/ */
-     for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
+     /*   fprintf(ficresf," V%d (=) %d",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
-       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 8863  void prevforecast(char fileres[], double
+ Line 11651  void prevforecast(char fileres[], double
            }
          }
          fprintf(ficresf,"\n");
-         for(j=1;j<=cptcoveff;j++)
+         /* for(j=1;j<=cptcoveff;j++)  */
-           fprintf(ficresf,"%d %d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,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,"%.f %.f ",anprojd+yearp,agec+h*hstepm/YEARM*stepm);
          for(j=1; j<=nlstate+ndeath;j++) {
- Line 8901  void prevforecast(char fileres[], double
+ Line 11692  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 8956  void prevforecast(char fileres[], double
+ Line 11747  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,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 9009  void prevforecast(char fileres[], double
+ Line 11806  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,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 9069  void prevforecast(char fileres[], double
+ Line 11868  void prevforecast(char fileres[], double
      i1=pow(2,cptcoveff);
      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++){
+        k=TKresult[nres];
+        if(TKresult[nres]==0) k=1; /* To be checked for noresult */
+      /* for(k=1; k<=i1;k++){ /\* We find the combination equivalent to result line values of dummies *\/ */
        if(i1 != 1 && TKresult[nres]!= k)
          continue;
        fprintf(ficresvpl,"\n#****** ");
        printf("\n#****** ");
        fprintf(ficlog,"\n#****** ");
-       for(j=1;j<=cptcoveff;j++) {
+       for(j=1;j<=cptcovs;j++) {
-         fprintf(ficresvpl,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+         fprintf(ficresvpl,"V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
-         fprintf(ficlog,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+         fprintf(ficlog,"V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
-         printf("V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+         printf("V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
-       }
+         /* fprintf(ficlog,"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=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
-         printf(" V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+       }
-         fprintf(ficresvpl," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+       /* for (j=1; j<= nsq; j++){ /\* For each selected (single) quantitative value *\/ */
-         fprintf(ficlog," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+       /*        printf(" V%d=%f ",Tvqresult[nres][j],Tqresult[nres][resultmodel[nres][j]]); */
-       }
+       /*        fprintf(ficresvpl," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][resultmodel[nres][j]]); */
+       /*        fprintf(ficlog," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][resultmodel[nres][j]]); */
+       /* }       */
        fprintf(ficresvpl,"******\n");
        printf("******\n");
        fprintf(ficlog,"******\n");
- Line 9126  void prevforecast(char fileres[], double
+ Line 11929  void prevforecast(char fileres[], double
     i1=pow(2,cptcoveff);
     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++){
+      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(i1 != 1 && TKresult[nres]!= k) */
+     /*   continue; */
         fprintf(ficresvbl,"\n#****** ");
         printf("\n#****** ");
         fprintf(ficlog,"\n#****** ");
-        for(j=1;j<=cptcoveff;j++) {
+        for (j=1; j<= cptcovs; j++){ /* For each selected (single) quantitative value */
-          fprintf(ficresvbl,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+          printf(" V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][resultmodel[nres][j]]);
-          fprintf(ficlog,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+          fprintf(ficresvbl," V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][resultmodel[nres][j]]);
-          printf("V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+          fprintf(ficlog," V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][resultmodel[nres][j]]);
-        }
+        /* for(j=1;j<=cptcoveff;j++) { */
-        for (j=1; j<= nsq; j++){ /* For each selected (single) quantitative value */
+        /*        fprintf(ficresvbl,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
-          printf(" V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+        /*        fprintf(ficlog,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
-          fprintf(ficresvbl," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+        /*        printf("V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
-          fprintf(ficlog," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+        /* } */
+        /* for (j=1; j<= nsq; j++){ /\* For each selected (single) quantitative value *\/ */
+        /*        printf(" V%d=%f ",Tvqresult[nres][j],Tqresult[nres][resultmodel[nres][j]]); */
+        /*        fprintf(ficresvbl," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][resultmodel[nres][j]]); */
+        /*        fprintf(ficlog," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][resultmodel[nres][j]]); */
         }
         fprintf(ficresvbl,"******\n");
         printf("******\n");
- Line 9485  double gompertz(double x[])
+ Line 12294  double gompertz(double x[])
           A=-x[1]/(x[2])*(exp(x[2]*(agecens[i]-agegomp))-exp(x[2]*(ageexmed[i]-agegomp)));
         } else if (cens[i] == 0){
          A=-x[1]/(x[2])*(exp(x[2]*(agedc[i]-agegomp))-exp(x[2]*(ageexmed[i]-agegomp)))
-           +log(x[1]/YEARM) +x[2]*(agedc[i]-agegomp)+log(YEARM);
+           +log(fabs(x[1])/YEARM) +x[2]*(agedc[i]-agegomp)+log(YEARM);
+         /* +log(x[1]/YEARM) +x[2]*(agedc[i]-agegomp)+log(YEARM); */  /* To be seen */
        } else
           printf("Gompertz cens[%d] neither 1 nor 0\n",i);
        /*if (wav[i] > 1 && agecens[i] > 15) {*/ /* ??? */
- Line 9569  void printinggnuplotmort(char fileresu[]
+ Line 12379  void printinggnuplotmort(char fileresu[]
    char dirfileres[132],optfileres[132];
-   int ng;
+   /*int ng;*/
    /*#ifdef windows */
- Line 9593  int readdata(char datafile[], int firsto
+ Line 12403  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 9601  int readdata(char datafile[], int firsto
+ Line 12411  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;
+   ncovcolt=ncovcol+nqv+ntv+nqtv; /* total of covariates in the data, not in the model equation */
-     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]);
-   }
    if((fic=fopen(datafile,"r"))==NULL)    {
      printf("Problem while opening datafile: %s with errno='%s'\n", datafile,strerror(errno));fflush(stdout);
      fprintf(ficlog,"Problem while opening datafile: %s with errno='%s'\n", datafile,strerror(errno));fflush(ficlog);return 1;
- Line 9706  int readdata(char datafile[], int firsto
+ Line 12493  int readdata(char datafile[], int firsto
          if(strb[0]=='.') { /* Missing value */
            lval=-1;
            cotqvar[j][iv][i]=-1; /* 0.0/0.0 */
-           cotvar[j][ntv+iv][i]=-1; /* For performance reasons */
+           cotvar[j][ncovcol+nqv+ntv+iv][i]=-1; /* For performance reasons */
            if(isalpha(strb[1])) { /* .m or .d Really Missing value */
              printf("Error reading data around '%s' at line number %d for individual %d, '%s'\nShould be the %d th quantitative value out of %d measured at wave %d. If missing, you should remove this individual or impute a value.  Exiting.\n", strb, linei,i,line,iv, nqtv, j);
              fprintf(ficlog,"Error reading data around '%s' at line number %d for individual %d, '%s'\nShould be the %d th quantitative value out of %d measured at wave %d. If missing, you should remove this individual or impute a value.  Exiting.\n", strb, linei,i,line,iv, nqtv, j);fflush(ficlog);
- Line 9726  int readdata(char datafile[], int firsto
+ Line 12513  int readdata(char datafile[], int firsto
              return 1;
            }
            cotqvar[j][iv][i]=dval;
-           cotvar[j][ntv+iv][i]=dval;
+           cotvar[j][ncovcol+nqv+ntv+iv][i]=dval; /* because cotvar starts now at first ntv */
          }
          strcpy(line,stra);
        }/* end loop ntqv */
- Line 9766  int readdata(char datafile[], int firsto
+ Line 12553  int readdata(char datafile[], int firsto
   Exiting.\n",lval,linei, i,line,iv,j);fflush(ficlog);
            return 1;
          }
-         cotvar[j][iv][i]=(double)(lval);
+         cotvar[j][ncovcol+nqv+iv][i]=(double)(lval);
          strcpy(line,stra);
        }/* end loop ntv */
- Line 9778  int readdata(char datafile[], int firsto
+ Line 12565  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 9966  void removefirstspace(char **stri){/*, c
+ Line 12757  void removefirstspace(char **stri){/*, c
    *stri=p2;
  }
- int decoderesult ( char resultline[], int nres)
+ int decoderesult( char resultline[], int nres)
  /**< This routine decode one result line and returns the combination # of dummy covariates only **/
  {
    int j=0, k=0, k1=0, k2=0, k3=0, k4=0, match=0, k2q=0, k3q=0, k4q=0;
    char resultsav[MAXLINE];
-   int resultmodel[MAXLINE];
+   /* int resultmodel[MAXLINE]; */
-   int modelresult[MAXLINE];
+   /* int modelresult[MAXLINE]; */
    char stra[80], strb[80], strc[80], strd[80],stre[80];
    removefirstspace(&resultline);
+   printf("decoderesult:%s\n",resultline);
-   if (strstr(resultline,"v") !=0){
+   strcpy(resultsav,resultline);
-     printf("Error. 'v' must be in upper case 'V' result: %s ",resultline);
+   /* printf("Decoderesult resultsav=\"%s\" resultline=\"%s\"\n", resultsav, resultline); */
-     fprintf(ficlog,"Error. 'v' must be in upper case result: %s ",resultline);fflush(ficlog);
-     return 1;
-   }
-   trimbb(resultsav, resultline);
    if (strlen(resultsav) >1){
-     j=nbocc(resultsav,'='); /**< j=Number of covariate values'=' */
+     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 this result line, %d, differs from the number of variables used in the model line, %d.\n",j, cptcovs);
+     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, %d, differs from the number of variables used in the model line, %d.\n",j, cptcovs);
+     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);
+     if(j==0)
+       return 1;
    }
-   for(k=1; k<=j;k++){ /* Loop on any covariate of the result line */
+   for(k=1; k<=j;k++){ /* Loop on any covariate of the RESULT LINE */
      if(nbocc(resultsav,'=') >1){
        cutl(stra,strb,resultsav,' '); /* keeps in strb after the first ' ' (stra is the rest of the resultline to be analyzed in the next loop *//*     resultsav= "V4=1 V5=25.1 V3=0" stra= "V5=25.1 V3=0" strb= "V4=1" */
+       /* If resultsav= "V4= 1 V5=25.1 V3=0" with a blank then strb="V4=" and stra="1 V5=25.1 V3=0" */
        cutl(strc,strd,strb,'=');  /* strb:"V4=1" strc="1" strd="V4" */
+       /* If a blank, then strc="V4=" and strd='\0' */
+       if(strc[0]=='\0'){
+       printf("Error in resultline, probably a blank after the \"%s\", \"result:%s\", stra=\"%s\" resultsav=\"%s\"\n",strb,resultline, stra, resultsav);
+         fprintf(ficlog,"Error in resultline, probably a blank after the \"V%s=\", resultline=%s\n",strb,resultline);
+         return 1;
+       }
      }else
        cutl(strc,strd,resultsav,'=');
      Tvalsel[k]=atof(strc); /* 1 */ /* Tvalsel of k is the float value of the kth covariate appearing in this result line */
- Line 10010  int decoderesult ( char resultline[], in
+ Line 12807  int decoderesult ( char resultline[], in
        strcpy(resultsav,stra); /* and analyzes it */
    }
    /* Checking for missing or useless values in comparison of current model needs */
-   for(k1=1; k1<= cptcovt ;k1++){ /* Loop on model. model line V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */
+   /* Feeds resultmodel[nres][k1]=k2 for k1th product covariate with age in the model equation fed by the index k2 of the resutline*/
-     if(Typevar[k1]==0){ /* Single covariate in model *//*0 for simple covariate (dummy, quantitative, fixed or varying), 1 for age product, 2 for  product */
+   for(k1=1; k1<= cptcovt ;k1++){ /* Loop on MODEL LINE V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */
+     if(Typevar[k1]==0){ /* Single covariate in model */
+       /* 0 for simple covariate (dummy, quantitative, fixed or varying), 1 for age product, 2 for  product */
        match=0;
        for(k2=1; k2 <=j;k2++){/* Loop on resultline. In result line V4=1 V5=24.1 V3=1  V2=8 V1=0 */
          if(Tvar[k1]==Tvarsel[k2]) {/* Tvar is coming from the model, Tvarsel from the result. Tvar[1]=5 == Tvarsel[2]=5   */
-           modelresult[k2]=k1;/* modelresult[2]=1 modelresult[1]=2  modelresult[3]=3  modelresult[6]=4 modelresult[9]=5 */
+           modelresult[nres][k2]=k1;/* modelresult[2]=1 modelresult[1]=2  modelresult[3]=3  modelresult[6]=4 modelresult[9]=5 */
            match=1; /* modelresult of k2 variable of resultline is identical to k1 variable of the model good */
            break;
          }
        }
        if(match == 0){
-         printf("Error in result line: V%d is missing in result: %s according to model=%s\n",k1, resultline, model);
+         printf("Error in result line (Dummy single): V%d is missing in result: %s according to model=1+age+%s. Tvar[k1=%d]=%d is different from Tvarsel[k2=%d]=%d.\n",Tvar[k1], resultline, model,k1, Tvar[k1], k2, Tvarsel[k2]);
-         fprintf(ficlog,"Error in result line: V%d is missing in result: %s according to model=%s\n",k1, resultline, model);
+         fprintf(ficlog,"Error in result line (Dummy single): V%d is missing in result: %s according to model=1+age+%s\n",Tvar[k1], resultline, model);
          return 1;
        }
-     }
+     }else if(Typevar[k1]==1){ /* Product with age We want to get the position k2 in the resultline of the product k1 in the model line*/
-   }
+       /* We feed resultmodel[k1]=k2; */
+       match=0;
+       for(k2=1; k2 <=j;k2++){/* Loop on resultline.  jth occurence of = signs in the result line. In result line V4=1 V5=24.1 V3=1  V2=8 V1=0 */
+         if(Tvar[k1]==Tvarsel[k2]) {/* Tvar is coming from the model, Tvarsel from the result. Tvar[1]=5 == Tvarsel[2]=5   */
+           modelresult[nres][k2]=k1;/* we found a Vn=1 corrresponding to Vn*age in the model modelresult[2]=1 modelresult[1]=2  modelresult[3]=3  modelresult[6]=4 modelresult[9]=5 */
+           resultmodel[nres][k1]=k2; /* Added here */
+           /* printf("Decoderesult first modelresult[k2=%d]=%d (k1) V%d*AGE\n",k2,k1,Tvar[k1]); */
+           match=1; /* modelresult of k2 variable of resultline is identical to k1 variable of the model good */
+           break;
+         }
+       }
+       if(match == 0){
+         printf("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]);
+         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 || 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]); */
+       for(k2=1; k2 <=j;k2++){/* Loop on resultline. In result line V4=1 V5=24.1 V3=1  V2=8 V1=0 */
+         if(Tvardk[k1][1]==Tvarsel[k2]) {/* Tvardk is coming from the model, Tvarsel from the result. Tvar[1]=5 == Tvarsel[2]=5   */
+           /* modelresult[k2]=k1; */
+           /* printf("Decoderesult first Product modelresult[k2=%d]=%d (k1) V%d * \n",k2,k1,Tvarsel[k2]); */
+           match=1; /* modelresult of k2 variable of resultline is identical to k1 variable of the model good */
+         }
+       }
+       if(match == 0){
+         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 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;
+       for(k2=1; k2 <=j;k2++){/* Loop on resultline. In result line V4=1 V5=24.1 V3=1  V2=8 V1=0 */
+         if(Tvardk[k1][2]==Tvarsel[k2]) {/* Tvardk is coming from the model, Tvarsel from the result. Tvar[1]=5 == Tvarsel[2]=5   */
+           /* modelresult[k2]=k1;*/
+           /* printf("Decoderesult second Product modelresult[k2=%d]=%d (k1) * V%d \n ",k2,k1,Tvarsel[k2]); */
+           match=1; /* modelresult of k2 variable of resultline is identical to k1 variable of the model good */
+           break;
+         }
+       }
+       if(match == 0){
+         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 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 */
+   }/* End loop cptcovt */
    /* Checking for missing or useless values in comparison of current model needs */
-   for(k2=1; k2 <=j;k2++){ /* Loop on resultline variables: result line V4=1 V5=24.1 V3=1  V2=8 V1=0 */
+   /* Feeds resultmodel[nres][k1]=k2 for single covariate (k1) in the model equation */
+   for(k2=1; k2 <=j;k2++){ /* j or cptcovs is the number of single covariates used either in the model line as well as in the result line (dummy or quantitative)
+                            * Loop on resultline variables: result line V4=1 V5=24.1 V3=1  V2=8 V1=0 */
      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 */
+       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[k1]=k2;  /* k2th variable of the model corresponds to k1 variable of the model. resultmodel[2]=1 resultmodel[1]=2  resultmodel[3]=3  resultmodel[6]=4 resultmodel[9]=5 */
+           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;
          }
        }
      }
      if(match == 0){
-       printf("Error in result line: %d value missing; result: %s, model=%s\n",k1, resultline, model);
+       printf("Error in result line: variable V%d is missing in model; result: %s, model=1+age+%s\n",Tvarsel[k2], resultline, model);
-       fprintf(ficlog,"Error in result line: %d value missing; result: %s, model=%s\n",k1, resultline, model);
+       fprintf(ficlog,"Error in result line: variable V%d is missing in model; result: %s, model=1+age+%s\n",Tvarsel[k2], resultline, model);
        return 1;
      }else if(match > 1){
-       printf("Error in result line: %d doubled; result: %s, model=%s\n",k2, resultline, model);
+       printf("Error in result line: %d doubled; result: %s, model=1+age+%s\n",k2, resultline, model);
-       fprintf(ficlog,"Error in result line: %d doubled; result: %s, model=%s\n",k2, resultline, model);
+       fprintf(ficlog,"Error in result line: %d doubled; result: %s, model=1+age+%s\n",k2, resultline, model);
        return 1;
      }
    }
+   /* cptcovres=j /\* Number of variables in the resultline is equal to cptcovs and thus useless *\/     */
    /* We need to deduce which combination number is chosen and save quantitative values */
    /* model line V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */
-   /* result line V4=1 V5=25.1 V3=0  V2=8 V1=1 */
+   /* nres=1st result line: V4=1 V5=25.1 V3=0  V2=8 V1=1 */
-   /* should give a combination of dummy V4=1, V3=0, V1=1 => V4*2**(0) + V3*2**(1) + V1*2**(2) = 5 + (1offset) = 6*/
+   /* should correspond to the combination 6 of dummy: V4=1, V3=0, V1=1 => V4*2**(0) + V3*2**(1) + V1*2**(2) = 1*1 + 0*2 + 1*4 = 5 + (1offset) = 6*/
-   /* result line V4=1 V5=24.1 V3=1  V2=8 V1=0 */
+   /* nres=2nd result line: V4=1 V5=24.1 V3=1  V2=8 V1=0 */
    /* should give a combination of dummy V4=1, V3=1, V1=0 => V4*2**(0) + V3*2**(1) + V1*2**(2) = 3 + (1offset) = 4*/
    /*    1 0 0 0 */
    /*    2 1 0 0 */
    /*    3 0 1 0 */
-   /*    4 1 1 0 */ /* V4=1, V3=1, V1=0 */
+   /*    4 1 1 0 */ /* V4=1, V3=1, V1=0 (nres=2)*/
    /*    5 0 0 1 */
-   /*    6 1 0 1 */ /* V4=1, V3=0, V1=1 */
+   /*    6 1 0 1 */ /* V4=1, V3=0, V1=1 (nres=1)*/
    /*    7 0 1 1 */
    /*    8 1 1 1 */
    /* V(Tvresult)=Tresult V4=1 V3=0 V1=1 Tresult[nres=1][2]=0 */
    /* V(Tvqresult)=Tqresult V5=25.1 V2=8 Tqresult[nres=1][1]=25.1 */
    /* V5*age V5 known which value for nres?  */
    /* Tqinvresult[2]=8 Tqinvresult[1]=25.1  */
-   for(k1=1, k=0, k4=0, k4q=0; k1 <=cptcovt;k1++){ /* loop on model line */
+   for(k1=1, k=0, k4=0, k4q=0; k1 <=cptcovt;k1++){ /* cptcovt number of covariates (excluding 1 and age or age*age) in the MODEL equation.
-     if( Dummy[k1]==0 && Typevar[k1]==0 ){ /* Single dummy */
+                                                    * loop on position k1 in the MODEL LINE */
-       k3= resultmodel[k1]; /* resultmodel[2(V4)] = 1=k3 */
+     /* k counting number of combination of single dummies in the equation model */
-       k2=(int)Tvarsel[k3]; /*  Tvarsel[resultmodel[2]]= Tvarsel[1] = 4=k2 */
+     /* k4 counting single dummies in the equation model */
-       k+=Tvalsel[k3]*pow(2,k4);  /*  Tvalsel[1]=1  */
+     /* k4q counting single quantitatives in the equation model */
-       Tresult[nres][k4+1]=Tvalsel[k3];/* Tresult[nres][1]=1(V4=1)  Tresult[nres][2]=0(V3=0) */
+     if( Dummy[k1]==0 && Typevar[k1]==0 ){ /* Dummy and Single, fixed or timevarying, k1 is sorting according to MODEL, but k3 to resultline */
-       Tvresult[nres][k4+1]=(int)Tvarsel[k3];/* Tvresult[nres][1]=4 Tvresult[nres][3]=1 */
+        /* 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 */
+       /* resultmodel[nres][k1]=k3: k1th position in the model correspond to the k3 position in the resultline                        */
+       /*      k3 is the position in the nres result line of the k1th variable of the model equation                                  */
+       /* Tvarsel[k3]: Name of the variable at the k3th position in the result line.                                                  */
+       /* Tvalsel[k3]: Value of the variable at the k3th position in the result line.                                                 */
+       /* Tresult[nres][result_position]= value of the dummy variable at the result_position in the nres resultline                   */
+       /* Tvresult[nres][result_position]= name of the dummy variable at the result_position in the nres resultline                     */
+       /* Tinvresult[nres][Name of a dummy variable]= value of the variable in the result line                                        */
+       /* TinvDoQresult[nres][Name of a Dummy or Q variable]= value of the variable in the result line                                                      */
+       k3= resultmodel[nres][k1]; /* From position k1 in model get position k3 in result line */
+       /* nres=1 k1=2 resultmodel[2(V4)] = 1=k3 ; k1=3 resultmodel[3(V3)] = 2=k3*/
+       k2=(int)Tvarsel[k3]; /* from position k3 in resultline get name k2: nres=1 k1=2=>k3=1 Tvarsel[resultmodel[2]]= Tvarsel[1] = 4=k2 (V4); k1=3=>k3=2 Tvarsel[2]=3 (V3)*/
+       k+=Tvalsel[k3]*pow(2,k4);  /* nres=1 k1=2 Tvalsel[1]=1 (V4=1); k1=3 k3=2 Tvalsel[2]=0 (V3=0) */
+       TinvDoQresult[nres][(int)Tvarsel[k3]]=Tvalsel[k3]; /* TinvDoQresult[nres][Name]=Value; stores the value into the name of the variable. */
+       /* Tinvresult[nres][4]=1 */
+       /* Tresult[nres][k4+1]=Tvalsel[k3];/\* Tresult[nres=2][1]=1(V4=1)  Tresult[nres=2][2]=0(V3=0) *\/ */
+       Tresult[nres][k3]=Tvalsel[k3];/* Tresult[nres=2][1]=1(V4=1)  Tresult[nres=2][2]=0(V3=0) */
+       /* Tvresult[nres][k4+1]=(int)Tvarsel[k3];/\* Tvresult[nres][1]=4 Tvresult[nres][3]=1 *\/ */
+       Tvresult[nres][k3]=(int)Tvarsel[k3];/* Tvresult[nres][1]=4 Tvresult[nres][3]=1 */
        Tinvresult[nres][(int)Tvarsel[k3]]=Tvalsel[k3]; /* Tinvresult[nres][4]=1 */
-       printf("Decoderesult Dummy k=%d, V(k2=V%d)= Tvalsel[%d]=%d, 2**(%d)\n",k, k2, k3, (int)Tvalsel[k3], k4);
+       precov[nres][k1]=Tvalsel[k3]; /* Value from resultline of the variable at the k1 position in the model */
+       /* printf("Decoderesult Dummy k=%d, k1=%d precov[nres=%d][k1=%d]=%.f V(k2=V%d)= Tvalsel[%d]=%d, 2**(%d)\n",k, k1, nres, k1,precov[nres][k1], k2, k3, (int)Tvalsel[k3], k4); */
        k4++;;
-     }  else if( Dummy[k1]==1 && Typevar[k1]==0 ){ /* Single quantitative */
+     }else if( Dummy[k1]==1 && Typevar[k1]==0 ){ /* Quantitative and single */
-       k3q= resultmodel[k1]; /* resultmodel[1(V5)] = 25.1=k3q */
+       /* Tqresult[nres][result_position]= value of the variable at the result_position in the nres resultline                                 */
-       k2q=(int)Tvarsel[k3q]; /*  Tvarsel[resultmodel[1]]= Tvarsel[1] = 4=k2 */
+       /* Tvqresult[nres][result_position]= id of the variable at the result_position in the nres resultline                                 */
-       Tqresult[nres][k4q+1]=Tvalsel[k3q]; /* Tqresult[nres][1]=25.1 */
+       /* Tqinvresult[nres][Name of a quantitative variable]= value of the variable in the result line                                                      */
-       Tvqresult[nres][k4q+1]=(int)Tvarsel[k3q]; /* Tvqresult[nres][1]=5 */
+       k3q= resultmodel[nres][k1]; /* resultmodel[1(V5)] = 5 =k3q */
+       k2q=(int)Tvarsel[k3q]; /*  Name of variable at k3q th position in the resultline */
+       /* Tvarsel[resultmodel[1]]= Tvarsel[1] = 4=k2 */
+       /* Tqresult[nres][k4q+1]=Tvalsel[k3q]; /\* Tqresult[nres][1]=25.1 *\/ */
+       /* Tvresult[nres][k4q+1]=(int)Tvarsel[k3q];/\* Tvresult[nres][1]=4 Tvresult[nres][3]=1 *\/ */
+       /* Tvqresult[nres][k4q+1]=(int)Tvarsel[k3q]; /\* Tvqresult[nres][1]=5 *\/ */
+       Tqresult[nres][k3q]=Tvalsel[k3q]; /* Tqresult[nres][1]=25.1 */
+       Tvresult[nres][k3q]=(int)Tvarsel[k3q];/* Tvresult[nres][1]=4 Tvresult[nres][3]=1 */
+       Tvqresult[nres][k3q]=(int)Tvarsel[k3q]; /* Tvqresult[nres][1]=5 */
        Tqinvresult[nres][(int)Tvarsel[k3q]]=Tvalsel[k3q]; /* Tqinvresult[nres][5]=25.1 */
-       printf("Decoderesult Quantitative nres=%d, V(k2q=V%d)= Tvalsel[%d]=%d, Tvarsel[%d]=%f\n",nres, k2q, k3q, Tvarsel[k3q], k3q, Tvalsel[k3q]);
+       TinvDoQresult[nres][(int)Tvarsel[k3q]]=Tvalsel[k3q]; /* Tqinvresult[nres][5]=25.1 */
+       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 "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 */ /* 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) */
+         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{
+         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 */
+       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{
+         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 || 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{
+       printf("Error Decoderesult probably a product  Dummy[%d]==%d && Typevar[%d]==%d\n", k1, Dummy[k1], k1, Typevar[k1]);
+       fprintf(ficlog,"Error Decoderesult probably a product  Dummy[%d]==%d && Typevar[%d]==%d\n", k1, Dummy[k1], k1, Typevar[k1]);
      }
    }
-   TKresult[nres]=++k; /* Combination for the nresult and the model */
+   TKresult[nres]=++k; /* Number of combinations of dummies for the nresult and the model =Tvalsel[k3]*pow(2,k4) + 1*/
    return (0);
  }
- Line 10100  int decodemodel( char model[], int lasto
+ Line 13010  int decodemodel( char model[], int lasto
          * - cptcovn or number of covariates k of the models excluding age*products =6 and age*age
          * - cptcovage number of covariates with age*products =2
          * - cptcovs number of simple covariates
+         * ncovcolt=ncovcol+nqv+ntv+nqtv total of covariates in the data, not in the model equation
          * - Tvar[k] is the id of the kth covariate Tvar[1]@12 {1, 2, 3, 8, 10, 11, 8, 3, 7, 8, 5, 6}, thus Tvar[5=V7*V8]=10
-         *     which is a new column after the 9 (ncovcol) variables.
+         *     which is a new column after the 9 (ncovcol+nqv+ntv+nqtv) variables.
          * - if k is a product Vn*Vm, covar[k][i] is filled with correct values for each individual
          * - Tprod[l] gives the kth covariates of the product Vn*Vm l=1 to cptcovprod-cptcovage
          *    Tprod[1]@2 {5, 6}: position of first product V7*V8 is 5, and second V5*V6 is 6.
- Line 10109  int decodemodel( char model[], int lasto
+ Line 13020  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);
        return 1;
      }
      if (strstr(model,"v") !=0){
-       printf("Error. 'v' must be in upper case 'V' model=%s ",model);
+       printf("Error. 'v' must be in upper case 'V' model=1+age+%s ",model);
-       fprintf(ficlog,"Error. 'v' must be in upper case model=%s ",model);fflush(ficlog);
+       fprintf(ficlog,"Error. 'v' must be in upper case model=1+age+%s ",model);fflush(ficlog);
        return 1;
      }
      strcpy(modelsav,model);
      if ((strpt=strstr(model,"age*age")) !=0){
-       printf(" strpt=%s, model=%s\n",strpt, model);
+       printf(" strpt=%s, model=1+age+%s\n",strpt, model);
        if(strpt != model){
-         printf("Error in model: 'model=%s'; 'age*age' should in first place before other covariates\n \
+         printf("Error in model: 'model=1+age+%s'; 'age*age' should in first place before other covariates\n \
   'model=1+age+age*age+V1.' or 'model=1+age+age*age+V1+V1*age.', please swap as well as \n \
   corresponding column of parameters.\n",model);
-         fprintf(ficlog,"Error in model: 'model=%s'; 'age*age' should in first place before other covariates\n \
+         fprintf(ficlog,"Error in model: 'model=1+age+%s'; 'age*age' should in first place before other covariates\n \
   'model=1+age+age*age+V1.' or 'model=1+age+age*age+V1+V1*age.', please swap as well as \n \
   corresponding column of parameters.\n",model); fflush(ficlog);
          return 1;
- Line 10149  int decodemodel( char model[], int lasto
+ Line 13067  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 10169  int decodemodel( char model[], int lasto
+ Line 13089  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 10215  int decodemodel( char model[], int lasto
+ Line 13135  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 10222  int decodemodel( char model[], int lasto
+ Line 13158  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; /* 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]=4 etc */
-             Typevar[k]=2;  /* 2 for double fixed dummy covariates */
              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*/
-             Tvard[k1][2] =atoi(stre); /* n 4 for V4*/
+             if(existcomb[n][m] == 0){
-             k2=k2+2;  /* k2 is initialize to -1, We want to store the n and m in Vn*Vm at the end of Tvar */
+               /*  r /home/brouard/Documents/Recherches/REVES/Zachary/Zach-2022/Feinuo_Sun/Feinuo-threeway/femV12V15_3wayintNBe.imach */
-             /* Tvar[cptcovt+k2]=Tvard[k1][1]; /\* Tvar[(cptcovt=4+k2=1)=5]= 1 (V1) *\/ */
+               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);
-             /* Tvar[cptcovt+k2+1]=Tvard[k1][2];  /\* Tvar[(cptcovt=4+(k2=1)+1)=6]= 4 (V4) *\/ */
+               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);
-             /*ncovcol=4 and model=V2+V1+V1*V4+age*V3+V3*V2, Tvar[3]=5, Tvar[4]=6, cptcovt=5 */
+               fflush(ficlog);
-             /*                     1  2   3      4     5 | Tvar[5+1)=1, Tvar[7]=2   */
+               k1++;  /* The combination Vn*Vm will be in the model so we create it at k1 */
-             for (i=1; i<=lastobs;i++){
+               k12++;
-               /* Computes the new covariate which is a product of
+               existcomb[n][m]=k1;
-                  covar[n][i]* covar[m][i] and stores it at ncovol+k1 May not be defined */
+               existcomb[m][n]=k1;
-               covar[ncovcol+k1][i]=covar[atoi(stre)][i]*covar[atoi(strc)][i];
+               Tvar[k]=ncovcol+nqv+ntv+nqtv+k1;
+               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*/
+               Tposprod[k]=k1; /* Tposprod[3]=1, Tposprod[2]=5 Gives the k1 double product  Vn*Vm or age*Vn*Vm at the k position */
+               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;
+               }
              }
-           } /* End age is not in the model */
+             /* Tage[cptcovage]=k;  /\*  V2+V1+V4+V3*age Tvar[4]=3, Tage[1] = 4 or V1+V1*age Tvar[2]=1, Tage[1]=2 *\/ */
-         } /* End if model includes a product */
+             /* Tvar[k]=k11; /\* HERY *\/ */
-         else { /* not a product */
+           } 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 */
+               }
+             }else{ /*  for product Vn*Vm */
+               Typevar[k]=2;  /* 2 for product Vn*Vm */
+               cutl(stre,strb,strc,'V'); /* strc= Vn, stre is n; strb=V3*V2 stre=3 strc=*/
+               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 10282  int decodemodel( char model[], int lasto
+ Line 13360  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 10310  int decodemodel( char model[], int lasto
+ Line 13391  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<=cptcovt; k++){ Fixed[k]=0; Dummy[k]=0;}
+   for(k=-1;k<=NCOVMAX; k++){ Fixed[k]=0; Dummy[k]=0;}
-   for(k=1, ncovf=0, nsd=0, nsq=0, ncovv=0, ncova=0, ncoveff=0, nqfveff=0, ntveff=0, nqtveff=0;k<=cptcovt; k++){ /* or cptocvt */
+   for(k=1;k<=NCOVMAX; k++){TvarFind[k]=0; TvarVind[k]=0;}
+   /* 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 10328  Dummy[k] 0=dummy (0 1), 1 quantitative (
+ Line 13415  Dummy[k] 0=dummy (0 1), 1 quantitative (
        modell[k].maintype= FTYPE;
        TvarsD[nsd]=Tvar[k];
        TvarsDind[nsd]=k;
+       TnsdVar[Tvar[k]]=nsd;
        TvarF[ncovf]=Tvar[k];
        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 &&  Typevar[k]==2){ /* Product of fixed dummy (<=ncovcol) covariates */
+     /* }else if( Tvar[k] <=ncovcol &&  Typevar[k]==2){ /\* 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];
-       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 10349  Dummy[k] 0=dummy (0 1), 1 quantitative (
+ Line 13428  Dummy[k] 0=dummy (0 1), 1 quantitative (
        modell[k].maintype= FTYPE;
        modell[k].subtype= FQ;
        nsq++;
-       TvarsQ[nsq]=Tvar[k];
+       TvarsQ[nsq]=Tvar[k]; /* Gives the variable name (extended to products) of first nsq simple quantitative covariates (fixed or time vary see below */
-       TvarsQind[nsq]=k;
+       TvarsQind[nsq]=k;    /* Gives the position in the model equation of the first nsq simple quantitative covariates (fixed or time vary) */
        ncovf++;
        TvarF[ncovf]=Tvar[k];
        TvarFind[ncovf]=k;
        TvarFQ[nqfveff]=Tvar[k]-ncovcol; /* TvarFQ[1]=V2-1=1st in V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */ /* Only simple fixed quantitative variable */
        TvarFQind[nqfveff]=k; /* TvarFQind[1]=6 in V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */ /* Only simple fixed quantitative variable */
      }else if( Tvar[k] <=ncovcol+nqv+ntv && Typevar[k]==0){/* Only simple time varying dummy variables */
+       /*#  ID           V1     V2          weight               birth   death   1st    s1      V3      V4      V5       2nd  s2 */
+       /* model V1+V3+age*V1+age*V3+V1*V3 */
+       /*  Tvar={1, 3, 1, 3, 6}, the 6 comes from the fact that there are already V1, V2, V3, V4, V5 native covariates */
+       ncovvt++;
+       TvarVV[ncovvt]=Tvar[k];  /*  TvarVV[1]=V3 (first time varying in the model equation  */
+       TvarVVind[ncovvt]=k;    /*  TvarVVind[1]=2 (second position in the model equation  */
        Fixed[k]= 1;
        Dummy[k]= 0;
        ntveff++; /* Only simple time varying dummy variable */
- Line 10365  Dummy[k] 0=dummy (0 1), 1 quantitative (
+ Line 13451  Dummy[k] 0=dummy (0 1), 1 quantitative (
        nsd++;
        TvarsD[nsd]=Tvar[k];
        TvarsDind[nsd]=k;
+       TnsdVar[Tvar[k]]=nsd; /* To be verified */
        ncovv++; /* Only simple time varying variables */
        TvarV[ncovv]=Tvar[k];
        TvarVind[ncovv]=k; /* TvarVind[2]=2  TvarVind[3]=3 in V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */ /* Any time varying singele */
- Line 10373  Dummy[k] 0=dummy (0 1), 1 quantitative (
+ Line 13460  Dummy[k] 0=dummy (0 1), 1 quantitative (
        printf("Quasi Tmodelind[%d]=%d,Tvar[Tmodelind[%d]]=V%d, ncovcol=%d, nqv=%d,Tvar[k]- ncovcol-nqv=%d\n",ntveff,k,ntveff,Tvar[k], ncovcol, nqv,Tvar[k]- ncovcol-nqv);
        printf("Quasi TmodelInvind[%d]=%d\n",k,Tvar[k]- ncovcol-nqv);
      }else if( Tvar[k] <=ncovcol+nqv+ntv+nqtv  && Typevar[k]==0){ /* Only simple time varying quantitative variable V5*/
+       /*#  ID           V1     V2          weight               birth   death   1st    s1      V3      V4      V5       2nd  s2 */
+       /* model V1+V3+age*V1+age*V3+V1*V3 */
+       /*  Tvar={1, 3, 1, 3, 6}, the 6 comes from the fact that there are already V1, V2, V3, V4, V5 native covariates */
+       ncovvt++;
+       TvarVV[ncovvt]=Tvar[k];  /*  TvarVV[1]=V3 (first time varying in the model equation  */
+       TvarVVind[ncovvt]=k;  /*  TvarVV[1]=V3 (first time varying in the model equation  */
        Fixed[k]= 1;
        Dummy[k]= 1;
        nqtveff++;
- Line 10380  Dummy[k] 0=dummy (0 1), 1 quantitative (
+ Line 13474  Dummy[k] 0=dummy (0 1), 1 quantitative (
        modell[k].subtype= VQ;
        ncovv++; /* Only simple time varying variables */
        nsq++;
-       TvarsQ[nsq]=Tvar[k]; /* k=1 Tvar=5 nsq=1 TvarsQ[1]=5 */
+       TvarsQ[nsq]=Tvar[k]; /* k=1 Tvar=5 nsq=1 TvarsQ[1]=5 */ /* Gives the variable name (extended to products) of first nsq simple quantitative covariates (fixed or time vary here) */
-       TvarsQind[nsq]=k;
+       TvarsQind[nsq]=k; /* For single quantitative covariate gives the model position of each single quantitative covariate *//* Gives the position in the model equation of the first nsq simple quantitative covariates (fixed or time vary) */
        TvarV[ncovv]=Tvar[k];
        TvarVind[ncovv]=k; /* TvarVind[1]=1 in V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */ /* Any time varying singele */
        TvarVQ[nqtveff]=Tvar[k]; /* TvarVQ[1]=V5 in V5+V4+V3+V4*V3+V5*age+V2+V1*V2+V1*age+V1 */ /* Only simple time varying quantitative variable */
        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);
+       /* 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 without age */
+     }else if( Tposprod[k]>0  &&  Typevar[k]==2){  /* Detects if fixed product no age Vm*Vn */
-       k1=Tposprod[k];
+       printf("MEMORY ERRORR k=%d  Tposprod[k]=%d, Typevar[k]=%d\n ",k, Tposprod[k], Typevar[k]);
-       if(Tvard[k1][1] <=ncovcol){
+       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 */
-         if(Tvard[k1][2] <=ncovcol){
+       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]= 1;
+         Fixed[k]= 0;
-           Dummy[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 + 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 */
+       ncova++;
+       TvarA[ncova]=Tvard[k1][1];  /*  TvarVV[2]=V1 (because TvarVV[1] was V3, first time varying covariates */
+       TvarAind[ncova]=k;  /*  TvarVVind[2]=5 (because TvarVVind[2] was V1*V3 at position 5 */
+       ncova++;
+       TvarA[ncova]=Tvard[k1][2];  /*  TvarVV[3]=V3 */
+       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]= 2;
+           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 */
-         }else if(Tvard[k1][2] <=ncovcol+nqv){
+           Fixed[k]= 2;  /* Fixed product */
-           Fixed[k]= 0;  /* or 2 ?*/
+           Dummy[k]= 3;
-           Dummy[k]= 1;
            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 */
-         }else if(Tvard[k1][2] <=ncovcol+nqv+ntv){
+           Fixed[k]= 3;
-           Fixed[k]= 1;
+           Dummy[k]= 2;
-           Dummy[k]= 0;
            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];
+           TvarVind[ncova]=k;/* TvarVind[1]=5 */
-           TvarVind[ncovv]=k;
+         }else if(Tvard[k1][2] <=ncovcol+nqv+ntv+nqtv){ /* Vm is a time varying quantitative covariate */
-         }else if(Tvard[k1][2] <=ncovcol+nqv+ntv+nqtv){
+           Fixed[k]= 3;
-           Fixed[k]= 1;
+           Dummy[k]= 3;
-           Dummy[k]= 1;
            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){
+       }else if(Tvard[k1][1] <=ncovcol+nqv){ /* Vn is fixed quanti  */
-         if(Tvard[k1][2] <=ncovcol){
+         if(Tvard[k1][2] <=ncovcol){ /* Vm is fixed dummy */
-           Fixed[k]= 0;  /* or 2 ?*/
+           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){
+         }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){
+         }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){
+       }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){
+       }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]);
      }
-     printf("Decodemodel, k=%d, Tvar[%d]=V%d,Typevar=%d, Fixed=%d, Dummy=%d\n",k, k,Tvar[k],Typevar[k],Fixed[k],Dummy[k]);
+     /* printf("Decodemodel, k=%d, Tvar[%d]=V%d,Typevar=%d, Fixed=%d, Dummy=%d\n",k, k,Tvar[k],Typevar[k],Fixed[k],Dummy[k]); */
-     printf("           modell[%d].maintype=%d, modell[%d].subtype=%d\n",k,modell[k].maintype,k,modell[k].subtype);
+     /* 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 10571  Dummy[k] 0=dummy (0 1), 1 quantitative (
+ Line 13887  Dummy[k] 0=dummy (0 1), 1 quantitative (
        if((Typevar[k1]==Typevar[k2]) && (Fixed[k1]==Fixed[k2]) && (Dummy[k1]==Dummy[k2] )){
          if((Typevar[k1] == 0 || Typevar[k1] == 1)){ /* Simple or age product */
            if(Tvar[k1]==Tvar[k2]){
-             printf("Error duplication in the model=%s at positions (+) %d and %d, Tvar[%d]=V%d, Tvar[%d]=V%d, Typevar=%d, Fixed=%d, Dummy=%d\n", model, k1,k2, k1, Tvar[k1], k2, Tvar[k2],Typevar[k1],Fixed[k1],Dummy[k1]);
+             printf("Error duplication in the model=1+age+%s at positions (+) %d and %d, Tvar[%d]=V%d, Tvar[%d]=V%d, Typevar=%d, Fixed=%d, Dummy=%d\n", model, k1,k2, k1, Tvar[k1], k2, Tvar[k2],Typevar[k1],Fixed[k1],Dummy[k1]);
-             fprintf(ficlog,"Error duplication in the model=%s at positions (+) %d and %d, Tvar[%d]=V%d, Tvar[%d]=V%d, Typevar=%d, Fixed=%d, Dummy=%d\n", model, k1,k2, k1, Tvar[k1], k2, Tvar[k2],Typevar[k1],Fixed[k1],Dummy[k1]); fflush(ficlog);
+             fprintf(ficlog,"Error duplication in the model=1+age+%s at positions (+) %d and %d, Tvar[%d]=V%d, Tvar[%d]=V%d, Typevar=%d, Fixed=%d, Dummy=%d\n", model, k1,k2, k1, Tvar[k1], k2, Tvar[k2],Typevar[k1],Fixed[k1],Dummy[k1]); fflush(ficlog);
              return(1);
            }
          }else if (Typevar[k1] ==2){
            k3=Tposprod[k1];
            k4=Tposprod[k2];
            if( ((Tvard[k3][1]== Tvard[k4][1])&&(Tvard[k3][2]== Tvard[k4][2])) || ((Tvard[k3][1]== Tvard[k4][2])&&(Tvard[k3][2]== Tvard[k4][1])) ){
-             printf("Error duplication in the model=%s at positions (+) %d and %d, V%d*V%d, Typevar=%d, Fixed=%d, Dummy=%d\n",model, k1,k2, Tvard[k3][1], Tvard[k3][2],Typevar[k1],Fixed[Tvar[k1]],Dummy[Tvar[k1]]);
+             printf("Error duplication in the model=1+age+%s at positions (+) %d and %d, V%d*V%d, Typevar=%d, Fixed=%d, Dummy=%d\n",model, k1,k2, Tvard[k3][1], Tvard[k3][2],Typevar[k1],Fixed[Tvar[k1]],Dummy[Tvar[k1]]);
-             fprintf(ficlog,"Error duplication in the model=%s at positions (+) %d and %d, V%d*V%d, Typevar=%d, Fixed=%d, Dummy=%d\n",model, k1,k2, Tvard[k3][1], Tvard[k3][2],Typevar[k1],Fixed[Tvar[k1]],Dummy[Tvar[k1]]); fflush(ficlog);
+             fprintf(ficlog,"Error duplication in the model=1+age+%s at positions (+) %d and %d, V%d*V%d, Typevar=%d, Fixed=%d, Dummy=%d\n",model, k1,k2, Tvard[k3][1], Tvard[k3][2],Typevar[k1],Fixed[Tvar[k1]],Dummy[Tvar[k1]]); fflush(ficlog);
              return(1);
            }
          }
- Line 10591  Dummy[k] 0=dummy (0 1), 1 quantitative (
+ Line 13907  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 10907  void syscompilerinfo(int logged)
+ Line 14225  void syscompilerinfo(int logged)
  int prevalence_limit(double *p, double **prlim, double ageminpar, double agemaxpar, double ftolpl, int *ncvyearp){
    /*--------------- Prevalence limit  (forward period or forward stable prevalence) --------------*/
+   /* Computes the prevalence limit for each combination of the dummy covariates */
    int i, j, k, i1, k4=0, nres=0 ;
    /* double ftolpl = 1.e-10; */
    double age, agebase, agelim;
- Line 10935  int prevalence_limit(double *p, double *
+ Line 14254  int prevalence_limit(double *p, double *
    i1=pow(2,cptcoveff); /* Number of combination of dummy covariates */
    if (cptcovn < 1){i1=1;}
-   for(k=1; k<=i1;k++){ /* For each combination k of dummy covariates in the model */
+   /* for(k=1; k<=i1;k++){ /\* For each combination k of dummy covariates in the model *\/ */
      for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-       if(i1 != 1 && TKresult[nres]!= k)
+       k=TKresult[nres];
-         continue;
+       if(TKresult[nres]==0) k=1; /* To be checked for noresult */
+       /* if(i1 != 1 && TKresult[nres]!= k) /\* We found the combination k corresponding to the resultline value of dummies *\/ */
+       /*        continue; */
        /* for(cptcov=1,k=0;cptcov<=i1;cptcov++){ */
        /* for(cptcov=1,k=0;cptcov<=1;cptcov++){ */
        //for(cptcod=1;cptcod<=ncodemax[cptcov];cptcod++){
        /* k=k+1; */
        /* to clean */
-       //printf("cptcov=%d cptcod=%d codtab=%d\n",cptcov, cptcod,codtabm(cptcod,cptcov));
+       /*printf("cptcov=%d cptcod=%d codtab=%d\n",cptcov, cptcod,codtabm(cptcod,cptcov));*/
        fprintf(ficrespl,"#******");
        printf("#******");
        fprintf(ficlog,"#******");
-       for(j=1;j<=cptcoveff ;j++) {/* all covariates */
+       for(j=1;j<=cptcovs ;j++) {/**< cptcovs number of SIMPLE covariates in the model or resultline V2+V1 =2 (dummy or quantit or time varying) */
-         fprintf(ficrespl," V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]); /* Here problem for varying dummy*/
+         /* fprintf(ficrespl," V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,Tvaraff[j])]); /\* Here problem for varying dummy*\/ */
-         printf(" V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+         /* printf(" V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
-         fprintf(ficlog," V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+         /* fprintf(ficlog," V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
-       }
+         fprintf(ficrespl," V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
-       for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
+         printf(" V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
-         printf(" V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+         fprintf(ficlog," V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
-         fprintf(ficrespl," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+       }
-         fprintf(ficlog," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+       /* for (k4=1; k4<= nsq; k4++){ /\* For each selected (single) quantitative value *\/ */
-       }
+       /*        printf(" V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]); */
+       /*        fprintf(ficrespl," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]); */
+       /*        fprintf(ficlog," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]); */
+       /* } */
        fprintf(ficrespl,"******\n");
        printf("******\n");
        fprintf(ficlog,"******\n");
- Line 10970  int prevalence_limit(double *p, double *
+ Line 14294  int prevalence_limit(double *p, double *
        }
        fprintf(ficrespl,"#Age ");
-       for(j=1;j<=cptcoveff;j++) {
+       /* for(j=1;j<=cptcoveff;j++) { */
-         fprintf(ficrespl,"V%d %d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+       /*        fprintf(ficrespl,"V%d %d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
+       /* } */
+       for(j=1;j<=cptcovs;j++) { /* New the quanti variable is added */
+         fprintf(ficrespl,"V%d %lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
        }
        for(i=1; i<=nlstate;i++) fprintf(ficrespl,"  %d-%d   ",i,i);
        fprintf(ficrespl,"Total Years_to_converge\n");
        for (age=agebase; age<=agelim; age++){
          /* for (age=agebase; age<=agebase; age++){ */
-         prevalim(prlim, nlstate, p, age, oldm, savm, ftolpl, ncvyearp, k, nres);
+         /**< Computes the prevalence limit in each live state at age x and for covariate combination (k and) nres */
+         prevalim(prlim, nlstate, p, age, oldm, savm, ftolpl, ncvyearp, k, nres); /* Nicely done */
          fprintf(ficrespl,"%.0f ",age );
-         for(j=1;j<=cptcoveff;j++)
+         /* for(j=1;j<=cptcoveff;j++) */
-           fprintf(ficrespl,"%d %d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+         /*   fprintf(ficrespl,"%d %d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
+         for(j=1;j<=cptcovs;j++)
+           fprintf(ficrespl,"%d %lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
          tot=0.;
          for(i=1; i<=nlstate;i++){
            tot +=  prlim[i][i];
- Line 10990  int prevalence_limit(double *p, double *
+ Line 14320  int prevalence_limit(double *p, double *
          fprintf(ficrespl," %.3f %d\n", tot, *ncvyearp);
        } /* Age */
        /* was end of cptcod */
-     } /* cptcov */
+     } /* nres */
-   } /* nres */
+   /* } /\* for each combination *\/ */
    return 0;
  }
- Line 11033  int back_prevalence_limit(double *p, dou
+ Line 14363  int back_prevalence_limit(double *p, dou
    if (cptcovn < 1){i1=1;}
    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)
+       k=TKresult[nres];
-         continue;
+       if(TKresult[nres]==0) k=1; /* To be checked for noresult */
-       //printf("cptcov=%d cptcod=%d codtab=%d\n",cptcov, cptcod,codtabm(cptcod,cptcov));
+      /* if(i1 != 1 && TKresult[nres]!= k) */
+      /*         continue; */
+      /* /\*printf("cptcov=%d cptcod=%d codtab=%d\n",cptcov, cptcod,codtabm(cptcod,cptcov));*\/ */
        fprintf(ficresplb,"#******");
        printf("#******");
        fprintf(ficlog,"#******");
-       for(j=1;j<=cptcoveff ;j++) {/* all covariates */
+       for(j=1;j<=cptcovs ;j++) {/**< cptcovs number of SIMPLE covariates in the model or resultline V2+V1 =2 (dummy or quantit or time varying) */
-         fprintf(ficresplb," V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+         printf(" V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
-         printf(" V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+         fprintf(ficresplb," V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
-         fprintf(ficlog," V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+         fprintf(ficlog," V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
        }
-       for (j=1; j<= nsq; j++){ /* For each selected (single) quantitative value */
+       /* for(j=1;j<=cptcoveff ;j++) {/\* all covariates *\/ */
-         printf(" V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+       /*        fprintf(ficresplb," V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
-         fprintf(ficresplb," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+       /*        printf(" V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
-         fprintf(ficlog," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+       /*        fprintf(ficlog," 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=%f ",Tvqresult[nres][j],Tqresult[nres][resultmodel[nres][j]]); */
+       /*        fprintf(ficresplb," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][resultmodel[nres][j]]); */
+       /*        fprintf(ficlog," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][resultmodel[nres][j]]); */
+       /* } */
        fprintf(ficresplb,"******\n");
        printf("******\n");
        fprintf(ficlog,"******\n");
- Line 11061  int back_prevalence_limit(double *p, dou
+ Line 14398  int back_prevalence_limit(double *p, dou
        }
        fprintf(ficresplb,"#Age ");
-       for(j=1;j<=cptcoveff;j++) {
+       for(j=1;j<=cptcovs;j++) {
-         fprintf(ficresplb,"V%d %d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+         fprintf(ficresplb,"V%d %lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
        }
        for(i=1; i<=nlstate;i++) fprintf(ficresplb,"  %d-%d   ",i,i);
        fprintf(ficresplb,"Total Years_to_converge\n");
- Line 11085  int back_prevalence_limit(double *p, dou
+ Line 14422  int back_prevalence_limit(double *p, dou
            /* exit(1); */
          }
          fprintf(ficresplb,"%.0f ",age );
-         for(j=1;j<=cptcoveff;j++)
+         for(j=1;j<=cptcovs;j++)
-           fprintf(ficresplb,"%d %d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+           fprintf(ficresplb,"%d %lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
          tot=0.;
          for(i=1; i<=nlstate;i++){
            tot +=  bprlim[i][i];
- Line 11096  int back_prevalence_limit(double *p, dou
+ Line 14433  int back_prevalence_limit(double *p, dou
        } /* Age */
        /* was end of cptcod */
        /*fprintf(ficresplb,"\n");*/ /* Seems to be necessary for gnuplot only if two result lines and no covariate. */
-     } /* end of any combination */
+     /* } /\* end of any combination *\/ */
    } /* end of nres */
    /* hBijx(p, bage, fage); */
    /* fclose(ficrespijb); */
- Line 11106  int back_prevalence_limit(double *p, dou
+ Line 14443  int back_prevalence_limit(double *p, dou
  int hPijx(double *p, int bage, int fage){
      /*------------- h Pij x at various ages ------------*/
+   /* to be optimized with precov */
    int stepsize;
    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;
-     strcpy(filerespij,"PIJ_");  strcat(filerespij,fileresu);
+   strcpy(filerespij,"PIJ_");  strcat(filerespij,fileresu);
-     if((ficrespij=fopen(filerespij,"w"))==NULL) {
+   if((ficrespij=fopen(filerespij,"w"))==NULL) {
-       printf("Problem with Pij resultfile: %s\n", filerespij); return 1;
+     printf("Problem with Pij resultfile: %s\n", filerespij); return 1;
-       fprintf(ficlog,"Problem with Pij resultfile: %s\n", filerespij); return 1;
+     fprintf(ficlog,"Problem with Pij resultfile: %s\n", filerespij); return 1;
-     }
+   }
-     printf("Computing pij: result on file '%s' \n", filerespij);
+   printf("Computing pij: result on file '%s' \n", filerespij);
-     fprintf(ficlog,"Computing pij: result on file '%s' \n", filerespij);
+   fprintf(ficlog,"Computing pij: result on file '%s' \n", filerespij);
-     stepsize=(int) (stepm+YEARM-1)/YEARM;
+   stepsize=(int) (stepm+YEARM-1)/YEARM;
-     /*if (stepm<=24) stepsize=2;*/
+   /*if (stepm<=24) stepsize=2;*/
-     agelim=AGESUP;
+   agelim=AGESUP;
-     hstepm=stepsize*YEARM; /* Every year of age */
+   hstepm=stepsize*YEARM; /* Every year of age */
-     hstepm=hstepm/stepm; /* Typically 2 years, = 2/6 months = 4 */
+   hstepm=hstepm/stepm; /* Typically 2 years, = 2/6 months = 4 */
-     /* hstepm=1;   aff par mois*/
+   /* hstepm=1;   aff par mois*/
-     pstamp(ficrespij);
+   pstamp(ficrespij);
-     fprintf(ficrespij,"#****** h Pij x Probability to be in state j at age x+h being in i at x ");
+   fprintf(ficrespij,"#****** h Pij x Probability to be in state j at age x+h being in i at x ");
-     i1= pow(2,cptcoveff);
+   i1= pow(2,cptcoveff);
-                 /* for(cptcov=1,k=0;cptcov<=i1;cptcov++){ */
+   /* for(cptcov=1,k=0;cptcov<=i1;cptcov++){ */
-                 /*    /\*for(cptcod=1;cptcod<=ncodemax[cptcov];cptcod++){*\/ */
+   /*    /\*for(cptcod=1;cptcod<=ncodemax[cptcov];cptcod++){*\/ */
-                 /*      k=k+1;  */
+   /*    k=k+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++){
+     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++){ */
-       fprintf(ficrespij,"\n#****** ");
+     /* if(i1 != 1 && TKresult[nres]!= k) */
-       for(j=1;j<=cptcoveff;j++)
+     /*  continue; */
-         fprintf(ficrespij,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+     fprintf(ficrespij,"\n#****** ");
-       for (k4=1; k4<= nsq; k4++){ /* For each selected (single) quantitative value */
+     for(j=1;j<=cptcovs;j++){
-         printf(" V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+       fprintf(ficrespij," V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
-         fprintf(ficrespij," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]);
+       /* fprintf(ficrespij,"@wV%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(ficrespij,"******\n");
+       /*        printf(" V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]); */
+       /*        fprintf(ficrespij," V%d=%f ",Tvqresult[nres][k4],Tqresult[nres][k4]); */
-       for (agedeb=fage; agedeb>=bage; agedeb--){ /* If stepm=6 months */
+     }
-         nhstepm=(int) rint((agelim-agedeb)*YEARM/stepm); /* Typically 20 years = 20*12/6=40 */
+     fprintf(ficrespij,"******\n");
-         nhstepm = nhstepm/hstepm; /* Typically 40/4=10 */
+     for (agedeb=fage; agedeb>=bage; agedeb--){ /* If stepm=6 months */
-         /*        nhstepm=nhstepm*YEARM; aff par mois*/
+       nhstepm=(int) rint((agelim-agedeb)*YEARM/stepm); /* Typically 20 years = 20*12/6=40 */
+       nhstepm = nhstepm/hstepm; /* Typically 40/4=10 */
-         p3mat=ma3x(1,nlstate+ndeath,1, nlstate+ndeath, 0,nhstepm);
-         oldm=oldms;savm=savms;
+       /*          nhstepm=nhstepm*YEARM; aff par mois*/
-         hpxij(p3mat,nhstepm,agedeb,hstepm,p,nlstate,stepm,oldm,savm, k, nres);
-         fprintf(ficrespij,"# Cov Agex agex+h hpijx with i,j=");
+       p3mat=ma3x(1,nlstate+ndeath,1, nlstate+ndeath, 0,nhstepm);
+       oldm=oldms;savm=savms;
+       hpxij(p3mat,nhstepm,agedeb,hstepm,p,nlstate,stepm,oldm,savm, k, nres);
+       fprintf(ficrespij,"# Cov Agex agex+h hpijx with i,j=");
+       for(i=1; i<=nlstate;i++)
+         for(j=1; j<=nlstate+ndeath;j++)
+           fprintf(ficrespij," %1d-%1d",i,j);
+       fprintf(ficrespij,"\n");
+       for (h=0; h<=nhstepm; h++){
+         /*agedebphstep = agedeb + h*hstepm/YEARM*stepm;*/
+         fprintf(ficrespij,"%d %3.f %3.f",k, agedeb, agedeb + h*hstepm/YEARM*stepm );
          for(i=1; i<=nlstate;i++)
            for(j=1; j<=nlstate+ndeath;j++)
-             fprintf(ficrespij," %1d-%1d",i,j);
+             fprintf(ficrespij," %.5f", p3mat[i][j][h]);
-         fprintf(ficrespij,"\n");
-         for (h=0; h<=nhstepm; h++){
-           /*agedebphstep = agedeb + h*hstepm/YEARM*stepm;*/
-           fprintf(ficrespij,"%d %3.f %3.f",k, agedeb, agedeb + h*hstepm/YEARM*stepm );
-           for(i=1; i<=nlstate;i++)
-             for(j=1; j<=nlstate+ndeath;j++)
-               fprintf(ficrespij," %.5f", p3mat[i][j][h]);
-           fprintf(ficrespij,"\n");
-         }
-         free_ma3x(p3mat,1,nlstate+ndeath,1, nlstate+ndeath, 0,nhstepm);
          fprintf(ficrespij,"\n");
        }
-       /*}*/
+       free_ma3x(p3mat,1,nlstate+ndeath,1, nlstate+ndeath, 0,nhstepm);
+       fprintf(ficrespij,"\n");
      }
-     return 0;
+   }
+   /*}*/
+   return 0;
  }
   int hBijx(double *p, int bage, int fage, double ***prevacurrent){
      /*------------- h Bij x at various ages ------------*/
+     /* To be optimized with precov */
    int stepsize;
    /* int agelim; */
          int ageminl;
- Line 11218  int hPijx(double *p, int bage, int fage)
+ Line 14558  int hPijx(double *p, int bage, int fage)
    /*    /\*for(cptcod=1;cptcod<=ncodemax[cptcov];cptcod++){*\/ */
    /*    k=k+1;  */
    for(nres=1; nres <= nresult; nres++){ /* For each resultline */
-     for(k=1; k<=i1;k++){ /* For any combination of dummy covariates, fixed and varying */
+     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++){ /\* For any combination of dummy covariates, fixed and varying *\/ */
-       fprintf(ficrespijb,"\n#****** ");
+     /*    if(i1 != 1 && TKresult[nres]!= k) */
-       for(j=1;j<=cptcoveff;j++)
+     /*  continue; */
-         fprintf(ficrespijb,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+     fprintf(ficrespijb,"\n#****** ");
-       for (j=1; j<= nsq; j++){ /* For each selected (single) quantitative value */
+     for(j=1;j<=cptcovs;j++){
-         fprintf(ficrespijb," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+       fprintf(ficrespijb," V%d=%lg ",Tvresult[nres][j],TinvDoQresult[nres][Tvresult[nres][j]]);
-       }
+       /* for(j=1;j<=cptcoveff;j++) */
-       fprintf(ficrespijb,"******\n");
+       /*        fprintf(ficrespijb,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
-       if(invalidvarcomb[k]){  /* Is it necessary here? */
+       /* for (j=1; j<= nsq; j++){ /\* For each selected (single) quantitative value *\/ */
-         fprintf(ficrespijb,"\n#Combination (%d) ignored because no cases \n",k);
+       /*        fprintf(ficrespijb," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][resultmodel[nres][j]]); */
-         continue;
+     }
-       }
+     fprintf(ficrespijb,"******\n");
+     if(invalidvarcomb[k]){  /* Is it necessary here? */
+       fprintf(ficrespijb,"\n#Combination (%d) ignored because no cases \n",k);
+       continue;
+     }
+     /* for (agedeb=fage; agedeb>=bage; agedeb--){ /\* If stepm=6 months *\/ */
+     for (agedeb=bage; agedeb<=fage; agedeb++){ /* If stepm=6 months and estepm=24 (2 years) */
+       /* nhstepm=(int) rint((agelim-agedeb)*YEARM/stepm); /\* Typically 20 years = 20*12/6=40 *\/ */
+       nhstepm=(int) rint((agedeb-ageminl)*YEARM/stepm+0.1)-1; /* Typically 20 years = 20*12/6=40 or 55*12/24=27.5-1.1=>27 */
+       nhstepm = nhstepm/hstepm; /* Typically 40/4=10, because estepm=24 stepm=6 => hstepm=24/6=4 or 28*/
-       /* for (agedeb=fage; agedeb>=bage; agedeb--){ /\* If stepm=6 months *\/ */
+       /*          nhstepm=nhstepm*YEARM; aff par mois*/
-       for (agedeb=bage; agedeb<=fage; agedeb++){ /* If stepm=6 months and estepm=24 (2 years) */
-         /* nhstepm=(int) rint((agelim-agedeb)*YEARM/stepm); /\* Typically 20 years = 20*12/6=40 *\/ */
+       p3mat=ma3x(1,nlstate+ndeath,1, nlstate+ndeath, 0,nhstepm); /* We can't have it at an upper level because of nhstepm */
-         nhstepm=(int) rint((agedeb-ageminl)*YEARM/stepm+0.1)-1; /* Typically 20 years = 20*12/6=40 or 55*12/24=27.5-1.1=>27 */
+       /* and memory limitations if stepm is small */
-         nhstepm = nhstepm/hstepm; /* Typically 40/4=10, because estepm=24 stepm=6 => hstepm=24/6=4 or 28*/
+       /* oldm=oldms;savm=savms; */
-         /*        nhstepm=nhstepm*YEARM; aff par mois*/
+       /* hbxij(p3mat,nhstepm,agedeb,hstepm,p,nlstate,stepm,oldm,savm, k);   */
+       hbxij(p3mat,nhstepm,agedeb,hstepm,p,prevacurrent,nlstate,stepm, k, nres);/* Bug valgrind */
-         p3mat=ma3x(1,nlstate+ndeath,1, nlstate+ndeath, 0,nhstepm); /* We can't have it at an upper level because of nhstepm */
+       /* hbxij(p3mat,nhstepm,agedeb,hstepm,p,prevacurrent,nlstate,stepm,oldm,savm, dnewm, doldm, dsavm, k); */
-         /* and memory limitations if stepm is small */
+       fprintf(ficrespijb,"# Cov Agex agex-h hbijx with i,j=");
+       for(i=1; i<=nlstate;i++)
-         /* oldm=oldms;savm=savms; */
+         for(j=1; j<=nlstate+ndeath;j++)
-         /* hbxij(p3mat,nhstepm,agedeb,hstepm,p,nlstate,stepm,oldm,savm, k);   */
+           fprintf(ficrespijb," %1d-%1d",i,j);
-         hbxij(p3mat,nhstepm,agedeb,hstepm,p,prevacurrent,nlstate,stepm, k, nres);/* Bug valgrind */
+       fprintf(ficrespijb,"\n");
-         /* hbxij(p3mat,nhstepm,agedeb,hstepm,p,prevacurrent,nlstate,stepm,oldm,savm, dnewm, doldm, dsavm, k); */
+       for (h=0; h<=nhstepm; h++){
-         fprintf(ficrespijb,"# Cov Agex agex-h hbijx with i,j=");
+         /*agedebphstep = agedeb + h*hstepm/YEARM*stepm;*/
+         fprintf(ficrespijb,"%d %3.f %3.f",k, agedeb, agedeb - h*hstepm/YEARM*stepm );
+         /* fprintf(ficrespijb,"%d %3.f %3.f",k, agedeb, agedeb + h*hstepm/YEARM*stepm ); */
          for(i=1; i<=nlstate;i++)
            for(j=1; j<=nlstate+ndeath;j++)
-             fprintf(ficrespijb," %1d-%1d",i,j);
+             fprintf(ficrespijb," %.5f", p3mat[i][j][h]);/* Bug valgrind */
-         fprintf(ficrespijb,"\n");
-         for (h=0; h<=nhstepm; h++){
-           /*agedebphstep = agedeb + h*hstepm/YEARM*stepm;*/
-           fprintf(ficrespijb,"%d %3.f %3.f",k, agedeb, agedeb - h*hstepm/YEARM*stepm );
-           /* fprintf(ficrespijb,"%d %3.f %3.f",k, agedeb, agedeb + h*hstepm/YEARM*stepm ); */
-           for(i=1; i<=nlstate;i++)
-             for(j=1; j<=nlstate+ndeath;j++)
-               fprintf(ficrespijb," %.5f", p3mat[i][j][h]);/* Bug valgrind */
-           fprintf(ficrespijb,"\n");
-         }
-         free_ma3x(p3mat,1,nlstate+ndeath,1, nlstate+ndeath, 0,nhstepm);
          fprintf(ficrespijb,"\n");
-       } /* end age deb */
+       }
-     } /* end combination */
+       free_ma3x(p3mat,1,nlstate+ndeath,1, nlstate+ndeath, 0,nhstepm);
+       fprintf(ficrespijb,"\n");
+     } /* end age deb */
+     /* } /\* end combination *\/ */
    } /* end nres */
    return 0;
   } /*  hBijx */
- Line 11308  int main(int argc, char *argv[])
+ Line 14652  int main(int argc, char *argv[])
    double ageminpar=AGEOVERFLOW,agemin=AGEOVERFLOW, agemaxpar=-AGEOVERFLOW, agemax=-AGEOVERFLOW;
    double ageminout=-AGEOVERFLOW,agemaxout=AGEOVERFLOW; /* Smaller Age range redefined after movingaverage */
+   double stdpercent; /* for computing the std error of percent e.i: e.i/e.. */
    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];
-   char resultline[MAXLINE];
+   char resultline[MAXLINE], resultlineori[MAXLINE];
    char pathr[MAXLINE], pathimach[MAXLINE];
    char *tok, *val; /* pathtot */
-   int firstobs=1, lastobs=10; /* nobs = lastobs-firstobs declared globally ;*/
+   /* 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 11358  int main(int argc, char *argv[])
+ Line 14703  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 11416  int main(int argc, char *argv[])
+ Line 14761  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 11647  int main(int argc, char *argv[])
+ Line 14992  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 11661  int main(int argc, char *argv[])
+ Line 15017  int main(int argc, char *argv[])
          strcpy(model,modeltemp);
        }
      }
-     /* printf(" model=1+age%s modeltemp= %s, model=%s\n",model, modeltemp, model);fflush(stdout); */
+     /* printf(" model=1+age%s modeltemp= %s, model=1+age+%s\n",model, modeltemp, model);fflush(stdout); */
      printf("model=1+age+%s\n",model);fflush(stdout);
      fprintf(ficparo,"model=1+age+%s\n",model);fflush(stdout);
      fprintf(ficres,"model=1+age+%s\n",model);fflush(stdout);
- Line 11689  int main(int argc, char *argv[])
+ Line 15045  int main(int argc, char *argv[])
      numlinepar++;
      if(line[1]=='q'){ /* This #q will quit imach (the answer is q) */
        z[0]=line[1];
+     }else if(line[1]=='d'){ /* For debugging individual values of covariates in ficresilk */
+       debugILK=1;printf("DebugILK\n");
      }
      /* printf("****line [1] = %c \n",line[1]); */
      fputs(line, stdout);
- Line 11702  int main(int argc, char *argv[])
+ Line 15060  int main(int argc, char *argv[])
    covar=matrix(0,NCOVMAX,firstobs,lastobs);  /**< used in readdata */
    if(nqv>=1)coqvar=matrix(1,nqv,firstobs,lastobs);  /**< Fixed quantitative covariate */
    if(nqtv>=1)cotqvar=ma3x(1,maxwav,1,nqtv,firstobs,lastobs);  /**< Time varying quantitative covariate */
-   if(ntv+nqtv>=1)cotvar=ma3x(1,maxwav,1,ntv+nqtv,firstobs,lastobs);  /**< Time varying covariate (dummy and quantitative)*/
+   /* if(ntv+nqtv>=1)cotvar=ma3x(1,maxwav,1,ntv+nqtv,firstobs,lastobs);  /\**< Time varying covariate (dummy and quantitative)*\/ */
+   if(ntv+nqtv>=1)cotvar=ma3x(1,maxwav,ncovcol+nqv+1,ncovcol+nqv+ntv+nqtv,firstobs,lastobs);  /**< Might be better */
    cptcovn=0; /*Number of covariates, i.e. number of '+' in model statement plus one, indepently of n in Vn*/
    /* v1+v2+v3+v2*v4+v5*age makes cptcovn = 5
       v1+v2*age+v2*v3 makes cptcovn = 3
- Line 11945  Please run with mle=-1 to get a correct
+ Line 15304  Please run with mle=-1 to get a correct
    mint=matrix(1,maxwav,firstobs,lastobs);
    anint=matrix(1,maxwav,firstobs,lastobs);
    s=imatrix(1,maxwav+1,firstobs,lastobs); /* s[i][j] health state for wave i and individual j */
-   printf("BUG ncovmodel=%d NCOVMAX=%d 2**ncovmodel=%f BUG\n",ncovmodel,NCOVMAX,pow(2,ncovmodel));
+   /* printf("BUG ncovmodel=%d NCOVMAX=%d 2**ncovmodel=%f BUG\n",ncovmodel,NCOVMAX,pow(2,ncovmodel)); */
    tab=ivector(1,NCOVMAX);
    ncodemax=ivector(1,NCOVMAX); /* Number of code per covariate; if O and 1 only, 2**ncov; V1+V2+V3+V4=>16 */
    ncodemaxwundef=ivector(1,NCOVMAX); /* Number of code per covariate; if - 1 O and 1 only, 2**ncov; V1+V2+V3+V4=>16 */
- Line 11964  Please run with mle=-1 to get a correct
+ Line 15323  Please run with mle=-1 to get a correct
    Tvar=ivector(1,NCOVMAX); /* Was 15 changed to NCOVMAX. */
    TvarsDind=ivector(1,NCOVMAX); /*  */
+   TnsdVar=ivector(1,NCOVMAX); /*  */
+     /* for(i=1; i<=NCOVMAX;i++) TnsdVar[i]=3; */
    TvarsD=ivector(1,NCOVMAX); /*  */
    TvarsQind=ivector(1,NCOVMAX); /*  */
    TvarsQ=ivector(1,NCOVMAX); /*  */
- Line 11981  Please run with mle=-1 to get a correct
+ Line 15342  Please run with mle=-1 to get a correct
    TvarVDind=ivector(1,NCOVMAX); /*  */
    TvarVQ=ivector(1,NCOVMAX); /*  */
    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 12006  Please run with mle=-1 to get a correct
+ Line 15376  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(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 12025  Please run with mle=-1 to get a correct
+ Line 15396  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 12085  Please run with mle=-1 to get a correct
+ Line 15486  Please run with mle=-1 to get a correct
    Ndum =ivector(-1,NCOVMAX);
    cptcoveff=0;
    if (ncovmodel-nagesqr > 2 ){ /* That is if covariate other than cst, age and age*age */
-     tricode(&cptcoveff,Tvar,nbcode,imx, Ndum); /**< Fills nbcode[Tvar[j]][l]; */
+     tricode(&cptcoveff,Tvar,nbcode,imx, Ndum); /**< Fills nbcode[Tvar[j]][l]; as well as calculate cptcoveff or number of total effective dummy covariates*/
    }
    ncovcombmax=pow(2,cptcoveff);
-   invalidvarcomb=ivector(1, ncovcombmax);
+   invalidvarcomb=ivector(0, ncovcombmax);
-   for(i=1;i<ncovcombmax;i++)
+   for(i=0;i<ncovcombmax;i++)
      invalidvarcomb[i]=0;
    /* Nbcode gives the value of the lth modality (currently 1 to 2) of jth covariate, in
- Line 12115  Please run with mle=-1 to get a correct
+ Line 15516  Please run with mle=-1 to get a correct
             * For k=4 covariates, h goes from 1 to m=2**k
             * codtabm(h,k)=  (1 & (h-1) >> (k-1)) + 1;
             * #define codtabm(h,k)  (1 & (h-1) >> (k-1))+1
-            *     h\k   1     2     3     4
+            *     h\k   1     2     3     4   *  h-1\k-1  4  3  2  1
-            *______________________________
+            *______________________________   *______________________
-            *     1 i=1 1 i=1 1 i=1 1 i=1 1
+            *     1 i=1 1 i=1 1 i=1 1 i=1 1   *     0     0  0  0  0
-            *     2     2     1     1     1
+            *     2     2     1     1     1   *     1     0  0  0  1
-            *     3 i=2 1     2     1     1
+            *     3 i=2 1     2     1     1   *     2     0  0  1  0
-            *     4     2     2     1     1
+            *     4     2     2     1     1   *     3     0  0  1  1
-            *     5 i=3 1 i=2 1     2     1
+            *     5 i=3 1 i=2 1     2     1   *     4     0  1  0  0
-            *     6     2     1     2     1
+            *     6     2     1     2     1   *     5     0  1  0  1
-            *     7 i=4 1     2     2     1
+            *     7 i=4 1     2     2     1   *     6     0  1  1  0
-            *     8     2     2     2     1
+            *     8     2     2     2     1   *     7     0  1  1  1
-            *     9 i=5 1 i=3 1 i=2 1     2
+            *     9 i=5 1 i=3 1 i=2 1     2   *     8     1  0  0  0
-            *    10     2     1     1     2
+            *    10     2     1     1     2   *     9     1  0  0  1
-            *    11 i=6 1     2     1     2
+            *    11 i=6 1     2     1     2   *    10     1  0  1  0
-            *    12     2     2     1     2
+            *    12     2     2     1     2   *    11     1  0  1  1
-            *    13 i=7 1 i=4 1     2     2
+            *    13 i=7 1 i=4 1     2     2   *    12     1  1  0  0
-            *    14     2     1     2     2
+            *    14     2     1     2     2   *    13     1  1  0  1
-            *    15 i=8 1     2     2     2
+            *    15 i=8 1     2     2     2   *    14     1  1  1  0
-            *    16     2     2     2     2
+            *    16     2     2     2     2   *    15     1  1  1  1
             */
    /* How to do the opposite? From combination h (=1 to 2**k) how to get the value on the covariates? */
       /* from h=5 and m, we get then number of covariates k=log(m)/log(2)=4
       * and the value of each covariate?
- Line 12224  Title=%s <br>Datafile=%s Firstpass=%d La
+ Line 15625  Title=%s <br>Datafile=%s Firstpass=%d La
            optionfilehtmcov,version,fullversion,title,datafile,firstpass,lastpass,stepm, weightopt, model);
    }
-   fprintf(fichtm,"<html><head>\n<head>\n<meta charset=\"utf-8\"/><meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />\n<title>IMaCh %s</title></head>\n <body><font size=\"7\"><a href=http:/euroreves.ined.fr/imach>IMaCh for Interpolated Markov Chain</a> </font><br>\n<font size=\"3\">Sponsored by Copyright (C)  2002-2015 <a href=http://www.ined.fr>INED</a>-EUROREVES-Institut de longévité-2013-2016-Japan Society for the Promotion of Sciences 日本学術振興会 (<a href=https://www.jsps.go.jp/english/e-grants/>Grant-in-Aid for Scientific Research 25293121</a>) - <a href=https://software.intel.com/en-us>Intel Software 2015-2018</a></font><br>  \
+   fprintf(fichtm,"<html><head>\n<meta charset=\"utf-8\"/><meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />\n\
- <hr size=\"2\" color=\"#EC5E5E\"> \n\
+ <title>IMaCh %s</title></head>\n\
+  <body><font size=\"7\"><a href=http:/euroreves.ined.fr/imach>IMaCh for Interpolated Markov Chain</a> </font><br>\n\
+ <font size=\"3\">Sponsored by Copyright (C)  2002-2015 <a href=http://www.ined.fr>INED</a>\
+ -EUROREVES-Institut de longévité-2013-2022-Japan Society for the Promotion of Sciences 日本学術振興会 \
+ (<a href=https://www.jsps.go.jp/english/e-grants/>Grant-in-Aid for Scientific Research 25293121</a>) - \
+ <a href=https://software.intel.com/en-us>Intel Software 2015-2018</a></font><br> \n", optionfilehtm);
+   fprintf(fichtm,"<hr size=\"2\" color=\"#EC5E5E\"> \n\
  <font size=\"2\">IMaCh-%s <br> %s</font> \
  <hr size=\"2\" color=\"#EC5E5E\"> \n\
- Title=%s <br>Datafile=%s Firstpass=%d Lastpass=%d Stepm=%d Weight=%d Model=1+age+%s<br>\n\
+ This file: <a href=\"%s\">%s</a></br>Title=%s <br>Datafile=<a href=\"%s\">%s</a> Firstpass=%d Lastpass=%d Stepm=%d Weight=%d Model=1+age+%s<br>\n\
  \n\
  <hr  size=\"2\" color=\"#EC5E5E\">\
   <ul><li><h4>Parameter files</h4>\n\
- Line 12237  Title=%s <br>Datafile=%s Firstpass=%d La
+ Line 15645  Title=%s <br>Datafile=%s Firstpass=%d La
   - Log file of the run: <a href=\"%s\">%s</a><br>\n\
   - Gnuplot file name: <a href=\"%s\">%s</a><br>\n\
   - Date and time at start: %s</ul>\n",\
-           optionfilehtm,version,fullversion,title,datafile,firstpass,lastpass,stepm, weightopt, model,\
+           version,fullversion,optionfilehtm,optionfilehtm,title,datafile,datafile,firstpass,lastpass,stepm, weightopt, model, \
            optionfilefiname,optionfilext,optionfilefiname,optionfilext,\
            fileres,fileres,\
            filelog,filelog,optionfilegnuplot,optionfilegnuplot,strstart);
- Line 12255  Title=%s <br>Datafile=%s Firstpass=%d La
+ Line 15663  Title=%s <br>Datafile=%s Firstpass=%d La
    /* 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 12346  Interval (in months) between two waves:
+ Line 15754  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 12441  Interval (in months) between two waves:
+ Line 15849  Interval (in months) between two waves:
      gsl_multimin_fminimizer_free (sfm); /* p *(sfm.x.data) et p *(sfm.x.data+1)  */
  #endif
  #ifdef POWELL
-      powell(p,ximort,NDIM,ftol,&iter,&fret,gompertz);
+ #ifdef LINMINORIGINAL
- #endif
+ #else /* LINMINORIGINAL */
+   flatdir=ivector(1,npar);
+   for (j=1;j<=npar;j++) flatdir[j]=0;
+ #endif /*LINMINORIGINAL */
+     /* powell(p,ximort,NDIM,ftol,&iter,&fret,gompertz); */
+   /* double h0=0.25; */
+   macheps=pow(16.0,-13.0);
+   printf("Praxis Gegenfurtner mle=%d\n",mle);
+   fprintf(ficlog, "Praxis  Gegenfurtner mle=%d\n", mle);fflush(ficlog);
+    /* ffmin = praxis(ftol,macheps, h0, npar, prin, p, gompertz); */
+   /* For the Gompertz we use only two parameters */
+   int _npar=2;
+    ffmin = praxis(ftol,macheps, h0, _npar, 4, p, gompertz);
+   printf("End Praxis\n");
      fclose(ficrespow);
+ #ifdef LINMINORIGINAL
+ #else
+       free_ivector(flatdir,1,npar);
+ #endif  /* LINMINORIGINAL*/
      hesscov(matcov, hess, p, NDIM, delti, 1e-4, gompertz);
      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 12551  Please run with mle=-1 to get a correct
+ Line 15977  Please run with mle=-1 to get a correct
      globpr=1; /* again, to print the individual contributions using computed gpimx and gsw */
      likelione(ficres, p, npar, nlstate, &globpr, &ipmx, &sw, &fretone, funcone); /* Prints the contributions to the likelihood */
      printf("Second Likeli=%12.6f ipmx=%ld sw=%12.6f",fretone,ipmx,sw);
+           /* exit(0); */
      for (k=1; k<=npar;k++)
        printf(" %d %8.5f",k,p[k]);
      printf("\n");
- Line 12577  Please run with mle=-1 to get a correct
+ Line 16004  Please run with mle=-1 to get a correct
        fprintf(ficlog,"  + age*age  ");
        fprintf(fichtm, "<th>+ age*age</th>");
      }
-     for(j=1;j <=ncovmodel-2;j++){
+     for(j=1;j <=ncovmodel-2-nagesqr;j++){
        if(Typevar[j]==0) {
          printf("  +      V%d  ",Tvar[j]);
          fprintf(ficres,"  +      V%d  ",Tvar[j]);
- Line 12593  Please run with mle=-1 to get a correct
+ Line 16020  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 12643  Please run with mle=-1 to get a correct
+ Line 16075  Please run with mle=-1 to get a correct
          fprintf(ficlog,"  + age*age  ");
          fprintf(fichtm, "<th>+ age*age</th>");
        }
-       for(j=1;j <=ncovmodel-2;j++){
+       for(j=1;j <=ncovmodel-2-nagesqr;j++){
          if(Typevar[j]==0) {
            printf("  +      V%d  ",Tvar[j]);
            fprintf(fichtm, "<th>+ V%d</th>",Tvar[j]);
- Line 12652  Please run with mle=-1 to get a correct
+ Line 16084  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 12709  Please run with mle=-1 to get a correct
+ Line 16143  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 12895  Please run with mle=-1 to get a correct
+ Line 16329  Please run with mle=-1 to get a correct
      }
      /* Results */
+     /* 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;
      nresult=0;
      parameterline=0;
- Line 12968  Please run with mle=-1 to get a correct
+ Line 16405  Please run with mle=-1 to get a correct
          }
          break;
        case 13:
-         num_filled=sscanf(line,"result:%[^\n]\n",resultline);
+         num_filled=sscanf(line,"result:%[^\n]\n",resultlineori);
          nresult++; /* Sum of resultlines */
-         printf("Result %d: result:%s\n",nresult, resultline);
+         /* printf("Result %d: result:%s\n",nresult, resultlineori); */
+         /* removefirstspace(&resultlineori); */
+         if(strstr(resultlineori,"v") !=0){
+           printf("Error. 'v' must be in upper case 'V' result: %s ",resultlineori);
+           fprintf(ficlog,"Error. 'v' must be in upper case result: %s ",resultlineori);fflush(ficlog);
+           return 1;
+         }
+         trimbb(resultline, resultlineori); /* Suppressing double blank in the resultline */
+         /* printf("Decoderesult resultline=\"%s\" resultlineori=\"%s\"\n", resultline, resultlineori); */
          if(nresult > MAXRESULTLINESPONE-1){
            printf("ERROR: Current version of IMaCh limits the number of resultlines to %d, you used %d\nYou can use the 'r' parameter file '%s' which uses option mle=0 to get other results. ",MAXRESULTLINESPONE-1,nresult,rfileres);
            fprintf(ficlog,"ERROR: Current version of IMaCh limits the number of resultlines to %d, you used %d\nYou can use the 'r' parameter file '%s' which uses option mle=0 to get other results. ",MAXRESULTLINESPONE-1,nresult,rfileres);
            goto end;
          }
          if(!decoderesult(resultline, nresult)){ /* Fills TKresult[nresult] combination and Tresult[nresult][k4+1] combination values */
            fprintf(ficparo,"result: %s\n",resultline);
            fprintf(ficres,"result: %s\n",resultline);
- Line 13052  Please run with mle=-1 to get a correct
+ Line 16499  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 13079  Please run with mle=-1 to get a correct
+ Line 16526  Please run with mle=-1 to get a correct
      /*--------------- Prevalence limit  (period or stable prevalence) --------------*/
      /*#include "prevlim.h"*/  /* Use ficrespl, ficlog */
      prlim=matrix(1,nlstate,1,nlstate);
+     /* Computes the prevalence limit for each combination k of the dummy covariates by calling prevalim(k) */
      prevalence_limit(p, prlim,  ageminpar, agemaxpar, ftolpl, &ncvyear);
      fclose(ficrespl);
      /*------------- h Pij x at various ages ------------*/
      /*#include "hpijx.h"*/
+     /** h Pij x Probability to be in state j at age x+h being in i at x, for each combination k of dummies in the model line or to nres?*/
+     /* calls hpxij with combination k */
      hPijx(p, bage, fage);
      fclose(ficrespij);
      /* ncovcombmax=  pow(2,cptcoveff); */
-     /*-------------- Variance of one-step probabilities---*/
+     /*-------------- Variance of one-step probabilities for a combination ij or for nres ?---*/
      k=1;
      varprob(optionfilefiname, matcov, p, delti, nlstate, bage, fage,k,Tvar,nbcode, ncodemax,strstart);
- Line 13199  Please run with mle=-1 to get a correct
+ Line 16649  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,j)]);
+       /* for(j=1;j<=cptcoveff;j++) { */
-         printf("V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,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=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+         printf(" V%d=%lg ",TvarsQ[j], TinvDoQresult[nres][TvarsQ[j]]); /* TvarsQ[j] gives the name of the jth quantitative (fixed or time v) */
-         fprintf(ficreseij," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+         fprintf(ficreseij,"V%d=%lg ",TvarsQ[j], TinvDoQresult[nres][TvarsQ[j]]);
        }
        fprintf(ficreseij,"******\n");
        printf("******\n");
        eij=ma3x(1,nlstate,1,nlstate,(int) bage, (int) fage);
        oldm=oldms;savm=savms;
+       /* printf("HELLO Entering evsij bage=%d fage=%d k=%d estepm=%d nres=%d\n",(int) bage, (int)fage, k, estepm, nres); */
        evsij(eij, p, nlstate, stepm, (int) bage, (int)fage, oldm, savm, k, estepm, strstart, nres);
        free_ma3x(eij,1,nlstate,1,nlstate,(int) bage, (int)fage);
- Line 13231  Please run with mle=-1 to get a correct
+ Line 16685  Please run with mle=-1 to get a correct
      /*---------- State-specific expectancies and variances ------------*/
+     /* Should be moved in a function */
      strcpy(filerest,"T_");
      strcat(filerest,fileresu);
      if((ficrest=fopen(filerest,"w"))==NULL) {
- Line 13270  Please run with mle=-1 to get a correct
+ Line 16724  Please run with mle=-1 to get a correct
      i1=pow(2,cptcoveff); /* Number of combination of dummy covariates */
      if (cptcovn < 1){i1=1;}
-     for(nres=1; nres <= nresult; nres++) /* For each resultline */
+     for(nres=1; nres <= nresult; nres++) /* For each resultline, find the combination and output results according to the values of dummies and then quanti.  */
-     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. For each nres and each value at position k
-       if(i1 != 1 && TKresult[nres]!= k)
+                           * we know Tresult[nres][result_position]= value of the dummy variable at the result_position in the nres resultline
+                           * Tvqresult[nres][result_position]= id of the variable at the result_position in the nres resultline
+                           * and Tqresult[nres][result_position]= value of the variable at the result_position in the nres resultline */
+       /* */
+       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);
-       for(j=1;j<=cptcoveff;j++){
+       /* It might not be a good idea to mix dummies and quantitative */
-         printf("V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+       /* 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 *\/ */
-         fprintf(ficrest,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+       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 */
-         fprintf(ficlog,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+         /* printf("V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); /\* Output by variables in the resultline *\/ */
-       }
+         /* Tvaraff[j] is the name of the dummy variable in position j in the equation model:
-       for (j=1; j<= nsq; j++){ /* For each selected (single) quantitative value */
+          * Tvaraff[1]@9={4, 3, 0, 0, 0, 0, 0, 0, 0}, in model=V5+V4+V3+V4*V3+V5*age
-         printf(" V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+          * (V5 is quanti) V4 and V3 are dummies
-         fprintf(ficrest," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+          * TnsdVar[4] is the position 1 and TnsdVar[3]=2 in codtabm(k,l)(V4  V3)=V4  V3
-         fprintf(ficlog," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+          *                                                              l=1 l=2
-       }
+          *                                                           k=1  1   1   0   0
+          *                                                           k=2  2   1   1   0
+          *                                                           k=3 [1] [2]  0   1
+          *                                                           k=4  2   2   1   1
+          * If nres=1 result: V3=1 V4=0 then k=3 and outputs
+          * If nres=2 result: V4=1 V3=0 then k=2 and outputs
+          * nres=1 =>k=3 j=1 V4= nbcode[4][codtabm(3,1)=1)=0; j=2  V3= nbcode[3][codtabm(3,2)=2]=1
+          * nres=2 =>k=2 j=1 V4= nbcode[4][codtabm(2,1)=2)=1; j=2  V3= nbcode[3][codtabm(2,2)=1]=0
+          */
+         /* Tvresult[nres][j] Name of the variable at position j in this resultline */
+         /* Tresult[nres][j] Value of this variable at position j could be a float if quantitative  */
+ /* We give up with the combinations!! */
+         /* if(debugILK) */
+         /*   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  *\/ */ /* TinvDoQresult[nres][Name of the variable] */
+           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(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{
+             printf("varyi ");fprintf(ficlog,"varyi ");fprintf(ficrest,"varyi ");
+           }
+           /* fprintf(ficrest,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
+           /* fprintf(ficlog,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
+         }else if(Dummy[modelresult[nres][j]]==1){ /* Quanti variable */
+           /* For each selected (single) quantitative value */
+           printf(" V%d=%lg ",Tvqresult[nres][j],Tqresult[nres][j]);
+           fprintf(ficlog," V%d=%lg ",Tvqresult[nres][j],Tqresult[nres][j]);
+           fprintf(ficrest," V%d=%lg ",Tvqresult[nres][j],Tqresult[nres][j]);
+           if(Fixed[modelresult[nres][j]]==0){ /* Fixed */
+             printf("fixed ");fprintf(ficlog,"fixed ");fprintf(ficrest,"fixed ");
+           }else{
+             printf("varyi ");fprintf(ficlog,"varyi ");fprintf(ficrest,"varyi ");
+           }
+         }else{
+           printf("Error in computing T_ Dummy[modelresult[%d][%d]]=%d, modelresult[%d][%d]=%d cptcovs=%d, cptcoveff=%d \n", nres, j, Dummy[modelresult[nres][j]],nres,j,modelresult[nres][j],cptcovs, cptcoveff);  /* end if dummy  or quanti */
+           fprintf(ficlog,"Error in computing T_ Dummy[modelresult[%d][%d]]=%d, modelresult[%d][%d]=%d cptcovs=%d, cptcoveff=%d \n", nres, j, Dummy[modelresult[nres][j]],nres,j,modelresult[nres][j],cptcovs, cptcoveff);  /* end if dummy  or quanti */
+           exit(1);
+         }
+       } /* End loop for each variable in the resultline */
+       /* for (j=1; j<= nsq; j++){ /\* For each selected (single) quantitative value *\/ */
+       /*        printf(" V%d=%f ",Tvqresult[nres][j],Tqresult[nres][resultmodel[nres][j]]); /\* Wrong j is not in the equation model *\/ */
+       /*        fprintf(ficrest," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][resultmodel[nres][j]]); */
+       /*        fprintf(ficlog," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][resultmodel[nres][j]]); */
+       /* }       */
        fprintf(ficrest,"******\n");
        fprintf(ficlog,"******\n");
        printf("******\n");
        fprintf(ficresstdeij,"\n#****** ");
        fprintf(ficrescveij,"\n#****** ");
+       /* It could have been: for(j=1;j<=cptcoveff;j++) {printf("V=%d=%lg",Tvresult[nres][cpt],TinvDoQresult[nres][Tvresult[nres][cpt]]);} */
+       /* But it won't be sorted and depends on how the resultline is ordered */
        for(j=1;j<=cptcoveff;j++) {
-         fprintf(ficresstdeij,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+         fprintf(ficresstdeij,"V%d=%d ",Tvresult[nres][j],Tresult[nres][j]);
-         fprintf(ficrescveij,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+         /* fprintf(ficresstdeij,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[Tvaraff[j]])]); */
-       }
+         /* fprintf(ficrescveij,"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 */
+       }
-         fprintf(ficresstdeij," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+       for (j=1; j<= nsq; j++){ /* For each selected (single) quantitative value, TvarsQind gives the position of a quantitative in model equation  */
-         fprintf(ficrescveij," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+         fprintf(ficresstdeij," V%d=%lg ",Tvar[TvarsQind[j]],Tqresult[nres][resultmodel[nres][TvarsQind[j]]]);
+         fprintf(ficrescveij," V%d=%lg ",Tvar[TvarsQind[j]],Tqresult[nres][resultmodel[nres][TvarsQind[j]]]);
        }
        fprintf(ficresstdeij,"******\n");
        fprintf(ficrescveij,"******\n");
- Line 13307  Please run with mle=-1 to get a correct
+ Line 16815  Please run with mle=-1 to get a correct
        fprintf(ficresvij,"\n#****** ");
        /* pstamp(ficresvij); */
        for(j=1;j<=cptcoveff;j++)
-         fprintf(ficresvij,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,j)]);
+         fprintf(ficresvij,"V%d=%d ",Tvresult[nres][j],Tresult[nres][j]);
+         /* fprintf(ficresvij,"V%d=%d ",Tvaraff[j],nbcode[Tvaraff[j]][codtabm(k,TnsdVar[TnsdVar[Tvaraff[j]]])]); */
        for (j=1; j<= nsq; j++){ /* For each selected (single) quantitative value */
-         fprintf(ficresvij," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]);
+         /* fprintf(ficresvij," V%d=%f ",Tvqresult[nres][j],Tqresult[nres][j]); /\* To solve *\/ */
+         fprintf(ficresvij," V%d=%lg ",Tvqresult[nres][j],Tqresult[nres][resultmodel[nres][j]]); /* Solved */
        }
        fprintf(ficresvij,"******\n");
- Line 13332  Please run with mle=-1 to get a correct
+ Line 16842  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);
+         /* Call to varevsij to get cov(e.i, e.j)= vareij[i][j][(int)age]=sum_h sum_k trgrad(h_p.i) V(theta) grad(k_p.k) Equation 20 */
+         /* Depending of popbased which changes the prevalences, either cross-sectional or period */
          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,"# Age popbased mobilav e.. (std) ");
+         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 13367  Please run with mle=-1 to get a correct
+ Line 16882  Please run with mle=-1 to get a correct
                /*ZZZ  printf("%lf %lf ", prlim[i][i] ,eij[i][j][(int)age]);*/
                /* printf("%lf %lf ", prlim[i][i] ,eij[i][j][(int)age]); */
              }
-             epj[nlstate+1] +=epj[j];
+             epj[nlstate+1] +=epj[j]; /* epp=sum_j epj = sum_j sum_i w_i e_ij */
            }
            /* printf(" age %4.0f \n",age); */
-           for(i=1, vepp=0.;i <=nlstate;i++)
+           for(i=1, vepp=0.;i <=nlstate;i++)  /* Variance of total life expectancy e.. */
              for(j=1;j <=nlstate;j++)
-               vepp += vareij[i][j][(int)age];
+               vepp += vareij[i][j][(int)age]; /* sum_i sum_j cov(e.i, e.j) = var(e..) */
            fprintf(ficrest," %7.3f (%7.3f)", epj[nlstate+1],sqrt(vepp));
+           /* vareij[i][j] is the covariance  cov(e.i, e.j) and vareij[j][j] is the variance  of e.j  */
            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}]$$ */
+           /* \frac{\mu_x^2}{\mu_y^2} ( \frac{\sigma^2_x}{\mu_x^2}-2\frac{\sigma_{xy}}{\mu_x\mu_y} +\frac{\sigma^2_y}{\mu_y^2}) */
+           /* \frac{e_{.i}^2}{e_{..}^2} ( \frac{\Var e_{.i}}{e_{.i}^2}-2\frac{\Var e_{.i} + \sum_{j\ne i} \Cov e_{.j},e_{.i}}{e_{.i}e_{..}} +\frac{\Var e_{..}}{e_{..}^2})*/
+           /*\mu_x = epj[j], \sigma^2_x = vareij[j][j][(int)age] and \mu_y=epj[nlstate+1], \sigma^2_y=vepp \sigmaxy= */
+           /* vareij[j][j][(int)age]/epj[nlstate+1]^2 + vepp/epj[nlstate+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[j]/epj[j] + vepp/epj[j]/epj[j]/epj[j]/epj[j] )); */
+             for(i=1,stdpercent=0.;i<=nlstate;i++){ /* Computing cov(e..,e.j)=cov(sum_i e.i,e.j)=sum_i cov(e.i, e.j) */
+               stdpercent += vareij[i][j][(int)age];
+             }
+             stdpercent= epj[j]*epj[j]/epj[nlstate+1]/epj[nlstate+1]* (vareij[j][j][(int)age]/epj[j]/epj[j]-2.*stdpercent/epj[j]/epj[nlstate+1]+ vepp/epj[nlstate+1]/epj[nlstate+1]);
+             /* stdpercent= epj[j]*epj[j]/epj[nlstate+1]/epj[nlstate+1]*(vareij[j][j][(int)age]/epj[j]/epj[j] + vepp/epj[nlstate+1]/epj[nlstate+1]); */ /* Without covariance */
+             /* fprintf(ficrest," %7.3f (%7.3f)", epj[j]/epj[nlstate+1], sqrt( vareij[j][j][(int)age]/epj[nlstate+1]/epj[nlstate+1] + epj[j]*epj[j]*vepp/epj[nlstate+1]/epj[nlstate+1]/epj[nlstate+1]/epj[nlstate+1] )); */
+             fprintf(ficrest," %7.3f (%7.3f)", epj[j]/epj[nlstate+1], sqrt(stdpercent));
+           }
            fprintf(ficrest,"\n");
          }
        } /* End vpopbased */
- Line 13387  Please run with mle=-1 to get a correct
+ Line 16921  Please run with mle=-1 to get a correct
        printf("done selection\n");fflush(stdout);
        fprintf(ficlog,"done selection\n");fflush(ficlog);
-     } /* End k selection */
+     } /* End k selection or end covariate selection for nres */
      printf("done State-specific expectancies\n");fflush(stdout);
      fprintf(ficlog,"done State-specific expectancies\n");fflush(ficlog);
-     /* variance-covariance of forward period prevalence*/
+     /* variance-covariance of forward period prevalence */
      varprlim(fileresu, nresult, mobaverage, mobilavproj, bage, fage, prlim, &ncvyear, ftolpl, p, matcov, delti, stepm, cptcoveff);
      free_vector(weight,firstobs,lastobs);
+     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 13418  Please run with mle=-1 to get a correct
+ Line 16953  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);
-   if(ntv+nqtv>=1)free_ma3x(cotvar,1,maxwav,1,ntv+nqtv,firstobs,lastobs);
+   /* if(ntv+nqtv>=1)free_ma3x(cotvar,1,maxwav,1,ntv+nqtv,firstobs,lastobs); */
+   if(ntv+nqtv>=1)free_ma3x(cotvar,1,maxwav,ncovcol+nqv+1,ncovcol+nqv+ntv+nqtv,firstobs,lastobs);
    if(nqtv>=1)free_ma3x(cotqvar,1,maxwav,1,nqtv,firstobs,lastobs);
    if(nqv>=1)free_matrix(coqvar,1,nqv,firstobs,lastobs);
    free_matrix(covar,0,NCOVMAX,firstobs,lastobs);
- Line 13437  Please run with mle=-1 to get a correct
+ Line 16974  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);
    free_ivector(TvarsQind,1,NCOVMAX);
    free_ivector(TvarsD,1,NCOVMAX);
+   free_ivector(TnsdVar,1,NCOVMAX);
    free_ivector(TvarsDind,1,NCOVMAX);
    free_ivector(TvarFD,1,NCOVMAX);
    free_ivector(TvarFDind,1,NCOVMAX);
- Line 13459  Please run with mle=-1 to get a correct
+ Line 16997  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);
    free_ivector(Tvarsel,1,NCOVMAX);
    free_vector(Tvalsel,1,NCOVMAX);
    free_ivector(Tposprod,1,NCOVMAX);
    free_ivector(Tprod,1,NCOVMAX);
    free_ivector(Tvaraff,1,NCOVMAX);
-   free_ivector(invalidvarcomb,1,ncovcombmax);
+   free_ivector(invalidvarcomb,0,ncovcombmax);
    free_ivector(Tage,1,NCOVMAX);
    free_ivector(Tmodelind,1,NCOVMAX);
    free_ivector(TmodelInvind,1,NCOVMAX);
    free_ivector(TmodelInvQind,1,NCOVMAX);
+   /* 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); */
    fflush(fichtm);

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