/*************************************************************************
* External variables for the Bailey-Makeham model                        *
*   Commissioned by: R. Clifton Bailey, HCFA                             *
*                    Henry Krakauer, HCFA HSQB                           *
*   Based on code written by Jim Summe, NIH                              *
*   Author, Bill Rogers: Rand, Computing Resource Center                 *
*************************************************************************/

#include "compiler.h"

/* Dataset type */
#define RAW     1
#define STATAIN 2

/* Problem definition */
#define BAILEY 1
#if defined(BAILEY)
#define NSP 3
#define NDV 3
#endif
#if defined(LOGIST)
#define NSP 2
#define NDV 1
#endif
extern char model_name[];
extern char *spname[];
extern Int2 modelid;

/* Key dimensions */
#define         MAX_PARMS       256

/* Dataset Definition */
extern DOUBLE nobs;

/* Parsing */
extern int parm_number[];
extern int var_number[];
extern int parms;
extern char format[];
extern unsigned char fixed[];
extern char token[];
extern Int2 vars;
extern int dvlist[];
extern int weightvar;
extern int input_type;
extern int result;
extern char outbuf[];

/* Options */
extern DOUBLE ssexp;
extern DOUBLE nsf;
extern DOUBLE rhomax;
extern DOUBLE interval;
extern FILE *logf;
extern int nocons;
extern int rescale;
extern int has_interval;
extern int optiondvs;
extern int ndv;
extern int insight;
extern int onestep;
extern char logfile[];
extern char dsn[];
extern char outdsn[];
extern int idcons;
extern Int2 n_extra_vals;
extern DOUBLE extra_vals[];

/* Maximization */
extern int iter;
extern int maxiter;
extern int singularity;
extern int found_better_answer;
extern int id_largest_change;
extern int in_constant_pass;
extern int reasoniter;

extern DOUBLE ll0;
extern DOUBLE llr0;
extern DOUBLE llrlast;
extern DOUBLE absch;
extern DOUBLE lambda;
extern DOUBLE llr0;
extern DOUBLE theta[];     /* Values of the parameters (including fixed) */
extern double d[];         /* Data vector -- must be internal double format */
extern DOUBLE *ntheta;
extern DOUBLE *adiag;
extern float *pch;
extern float *lpch;
extern DOUBLE *a;
extern DOUBLE *q;
extern DOUBLE *means;
extern DOUBLE *dend;
extern DOUBLE sp0[];
extern DOUBLE tolerance;
extern char *ident[];
extern int MaxID;
extern int debug;
extern int trace;
extern DOUBLE autofix;
extern int firstpass;
extern Int2 error_flag;
extern int stopflag;
extern char misssym[];
extern Int2 labheads;

/***********************************************************************
*  The actual parameters are stored as a dense vector of numbers.      *
*    This is for convenience; fixed[] has information on the actual    *
*    status of the parameters.  The parameters are stored (X1,SP1),    *
*    (X2,SP1), ..   So actprm[i]%vars is the variable number, and      *
*    actprm[i]/vars is the structural parameter                        *
***********************************************************************/

extern Int2 *actprm;        /* Vector of actual parameter numbers */
extern Int2 actparm;        /* Number of actual parameters */

/* forward declarations */
#if defined(ANSI)
int lexopen(char *s, DOUBLE *p, DOUBLE *pend);
int lexinstall(char *s, int val);
void KeywordInstall();
int yyparse(void);
int mxlkhd(void);
void msetup(void);
void output(DOUBLE *a, DOUBLE *fa);
void yyerror2(char *s1, char *s2);
void yyerror(char *s);
int yylex(void);
int LookupID(char *s);
int LookupNum(DOUBLE d);
void mxerror(int i, char *s);
void print_parms();
void iter_report();
void dupblnk(int i);
void dupch(char c, int i);
void spout21(char *s);
void spout21o(void);
int outparm(char *outdsn);
int out_err(char *outdsn);
int rawread(void);
int stataread(void);
void variable_setup();
int stata_setup(char *s);
int set_variable(char *s, double *dptr);
char *datalocate(long i);
int matinvert(DOUBLE *a, DOUBLE *fa, DOUBLE *work, int n);
int cholsky(DOUBLE *a, int n, DOUBLE *fa);
void solve(DOUBLE *fa, DOUBLE *x, DOUBLE *b, int n);
void fps(double x, double *f1, double *f2);
void sps(double x, double *f1, double *f2, double *f3);
void solution();
double tprob(double x, double df);
double chiprob(double x, double df);
double fprob(double f, double df1, double df2);
DOUBLE partial(DOUBLE *dv, DOUBLE *sp, DOUBLE *d1, DOUBLE *d1e, DOUBLE *d2);
DOUBLE calc_ll(DOUBLE x);
DOUBLE ll(DOUBLE *q, DOUBLE *qe, DOUBLE *a, DOUBLE *acp, DOUBLE *theta, int NeedDeriv);
DOUBLE LL_compute(DOUBLE *dv, DOUBLE *sp, DOUBLE *spd,
	  DOUBLE *spe, DOUBLE *spd2, DOUBLE *weight, int NeedDerivatives);
int fix(int j);
void sprt(DOUBLE *a, int n, char *s);
void vprt(DOUBLE *a, int n, char *s);
#else
double tprob();
void solution();
DOUBLE calc_ll();
void mxerror();
DOUBLE ll();
DOUBLE partial();
void print_parms();
void iter_report();
DOUBLE LL_compute();
void dupblnk();
void dupch();
void spout21();
void spout21o();
#endif

/* Translations:

   data positions --> indpendent variable number      var_number[i]
   data positions --> character names                 ident[j]
   indpendent variable number --> data positions      parm_number[i]
   dependent variable number --> data positions       dvlist[i]

*/