int arma_list_y_position (arma_info *ainfo) { int ypos; if (arma_is_arima(ainfo)) { ypos = arma_has_seasonal(ainfo) ? 9 : 5; } else { ypos = arma_has_seasonal(ainfo) ? 7 : 4; } return ypos; }
static int arma_remove_const (arma_info *ainfo, const DATASET *dset) { int *list = ainfo->alist; int seasonal = arma_has_seasonal(ainfo); int diffs = arma_is_arima(ainfo); int xstart, ret = 0; int i, j; if (diffs) { xstart = (seasonal)? 10 : 6; } else { xstart = (seasonal)? 8 : 5; } for (i=xstart; i<=list[0]; i++) { if (list[i] == 0 || true_const(list[i], dset)) { for (j=i; j<list[0]; j++) { list[j] = list[j+1]; } list[0] -= 1; ret = 1; break; } } return ret; }
static void ainfo_data_to_model (arma_info *ainfo, MODEL *pmod) { pmod->ifc = ainfo->ifc; pmod->dfn = ainfo->nc - pmod->ifc; pmod->dfd = pmod->nobs - pmod->dfn; pmod->ncoeff = ainfo->nc; if (arma_has_seasonal(ainfo)) { gretl_model_set_int(pmod, "arma_P", ainfo->P); gretl_model_set_int(pmod, "arma_Q", ainfo->Q); gretl_model_set_int(pmod, "arma_pd", ainfo->pd); } if (ainfo->d > 0 || ainfo->D > 0) { gretl_model_set_int(pmod, "arima_d", ainfo->d); gretl_model_set_int(pmod, "arima_D", ainfo->D); } if (ainfo->nexo > 0) { gretl_model_set_int(pmod, "armax", 1); } if (ainfo->pmask != NULL) { gretl_model_set_string_as_data(pmod, "pmask", gretl_strdup(ainfo->pmask)); } if (ainfo->qmask != NULL) { gretl_model_set_string_as_data(pmod, "qmask", gretl_strdup(ainfo->qmask)); } }
static int check_arma_sep (arma_info *ainfo, int sep1) { int *list = ainfo->alist; int sep2 = (sep1 == 3)? 6 : 8; int i, err = 0; for (i=sep1+1; i<=list[0]; i++) { if (list[i] == LISTSEP) { if (i == sep2) { /* there's a second list separator in the right place: we've got a seasonal specification */ set_arma_has_seasonal(ainfo); } else { err = 1; } } } if (!err && sep1 == 4) { /* check for apparent but not "real" arima spec */ if (arma_has_seasonal(ainfo)) { if (list[2] == 0 && list[6] == 0) { gretl_list_delete_at_pos(list, 2); gretl_list_delete_at_pos(list, 5); unset_arma_is_arima(ainfo); } } else { if (list[2] == 0) { gretl_list_delete_at_pos(list, 2); unset_arma_is_arima(ainfo); } } } return err; }
static int arma_init_build_dataset (arma_info *ainfo, int ptotal, int narmax, const int *list, const DATASET *dset, DATASET *aset, int nonlin) { double **aZ = aset->Z; const double *y; const gretl_matrix *X = NULL; int i, j, k, kx, ky; int t, s, k0 = 2; int undo_diff = 0; int xstart; int err = 0; if (arima_levels(ainfo)) { /* we'll need differences for initialization */ err = arima_difference(ainfo, dset, 1); if (err) { return err; } undo_diff = 1; y = ainfo->y; X = ainfo->dX; } else if (arma_xdiff(ainfo)) { /* run init in levels (FIXME?) */ y = dset->Z[ainfo->yno]; } else { y = ainfo->y; } /* add variable names to auxiliary dataset */ arma_init_add_varnames(ainfo, ptotal, narmax, aset); /* starting position for reading exogeneous vars */ if (ainfo->d > 0 || ainfo->D > 0) { xstart = (arma_has_seasonal(ainfo))? 10 : 6; } else { xstart = (arma_has_seasonal(ainfo))? 8 : 5; } /* set "local" globals */ xlist = list + xstart; for (t=0; t<aset->n; t++) { int realt = t + ainfo->t1; int miss = 0; if (ainfo->yscale != 1.0 && !na(y[realt])) { aZ[1][t] = y[realt] * ainfo->yscale; } else { aZ[1][t] = y[realt]; } k = k0; kx = ptotal + ainfo->nexo + k0; for (i=0; i<ainfo->p; i++) { if (!AR_included(ainfo, i)) { continue; } s = realt - (i + 1); if (s < 0) { miss = 1; aZ[k++][t] = NADBL; for (j=0; j<narmax; j++) { aZ[kx++][t] = NADBL; } } else { aZ[k][t] = y[s]; if (ainfo->yscale != 1.0 && !na(y[s])) { aZ[k][t] *= ainfo->yscale; } k++; for (j=0; j<narmax; j++) { aZ[kx++][t] = get_xti(dset, j, s, X); } } } ky = ainfo->np + ainfo->P + k0; for (j=0; j<ainfo->P; j++) { s = realt - (j + 1) * ainfo->pd; k = ainfo->np + k0 + j; if (s < 0) { miss = 1; aZ[k][t] = NADBL; for (k=0; k<narmax; k++) { aZ[kx++][t] = NADBL; } } else { aZ[k][t] = y[s]; if (ainfo->yscale != 1.0 && !na(y[s])) { aZ[k][t] *= ainfo->yscale; } for (k=0; k<narmax; k++) { aZ[kx++][t] = get_xti(dset, k, s, X); } } for (i=0; i<ainfo->p; i++) { if (!AR_included(ainfo, i)) { continue; } s = realt - ((j + 1) * ainfo->pd + (i + 1)); if (s < 0) { miss = 1; aZ[ky++][t] = NADBL; for (k=0; k<narmax; k++) { aZ[kx++][t] = NADBL; } } else { aZ[ky][t] = y[s]; if (ainfo->yscale != 1.0 && !na(y[s])) { aZ[ky][t] *= ainfo->yscale; } ky++; for (k=0; k<narmax; k++) { aZ[kx++][t] = get_xti(dset, k, s, X); } } } } kx = ptotal + k0; for (i=0; i<ainfo->nexo; i++) { aZ[kx++][t] = get_xti(dset, i, realt, X); } if (miss) { aset->t1 = t + 1; } } if (nonlin && arma_missvals(ainfo)) { err = arma_init_add_dummies(ainfo, aset); } if (undo_diff) { arima_difference_undo(ainfo, dset); } #if AINIT_DEBUG fprintf(stderr, "arma init dataset:\n"); for (i=0; i<aset->v; i++) { fprintf(stderr, "var %d '%s', obs[0] = %g\n", i, aset->varname[i], aset->Z[i][0]); } #endif return err; }
static int real_hr_arma_init (double *coeff, const DATASET *dset, arma_info *ainfo, PRN *prn) { const int *list = ainfo->alist; int np = ainfo->p, nq = ainfo->q; int nP = ainfo->P, nQ = ainfo->Q; int ptotal = np + nP + np * nP; int qtotal = nq + nQ + nq * nQ; int nexo = ainfo->nexo; int pass1lags, pass1v; const double *y; DATASET *aset = NULL; int *pass1list = NULL; int *pass2list = NULL; int *arlags = NULL; int *malags = NULL; MODEL armod; int xstart; int m, pos, s; int i, j, t; int err = 0; pass1lags = (ainfo->Q + ainfo->P) * dset->pd; if (pass1lags < HR_MINLAGS) { pass1lags = HR_MINLAGS; } pass1v = pass1lags + nexo + 2; /* dependent variable */ if (arma_xdiff(ainfo)) { /* for initialization, use the level of y */ y = dset->Z[ainfo->yno]; } else { y = ainfo->y; } aset = create_auxiliary_dataset(pass1v + qtotal, ainfo->T, 0); if (aset == NULL) { return E_ALLOC; } #if AINIT_DEBUG fprintf(stderr, "hr_arma_init: dataset allocated: %d vars, %d obs\n", pass1v + qtotal, ainfo->T); #endif /* in case we bomb before estimating a model */ gretl_model_init(&armod, dset); /* Start building stuff for pass 1 */ pass1list = gretl_list_new(pass1v); if (pass1list == NULL) { err = E_ALLOC; goto bailout; } pass1list[1] = 1; pass1list[2] = 0; for (i=2; i<pass1v; i++) { pass1list[i+1] = i; } /* variable names */ strcpy(aset->varname[1], "y"); for (i=0; i<nexo; i++) { /* exogenous vars */ sprintf(aset->varname[i+1], "x%d", i); } for (i=1; i<=pass1lags; i++) { /* lags */ sprintf(aset->varname[i+1+nexo], "y_%d", i); } /* Fill the dataset with the data for pass 1 */ /* starting position for reading exogeneous vars */ if (ainfo->d > 0 || ainfo->D > 0) { xstart = (arma_has_seasonal(ainfo))? 10 : 6; } else { xstart = (arma_has_seasonal(ainfo))? 8 : 5; } for (t=0; t<ainfo->T; t++) { s = t + ainfo->t1; aset->Z[1][t] = y[s]; for (i=0, pos=2; i<nexo; i++) { m = list[xstart + i]; aset->Z[pos++][t] = dset->Z[m][s]; } for (i=1; i<=pass1lags; i++) { s = t + ainfo->t1 - i; aset->Z[pos++][t] = (s >= 0)? y[s] : NADBL; } } /* pass 1 proper */ armod = lsq(pass1list, aset, OLS, OPT_A); if (armod.errcode) { err = armod.errcode; goto bailout; } #if AINIT_DEBUG fprintf(stderr, "pass1 model: t1=%d, t2=%d, nobs=%d, ncoeff=%d, dfd = %d\n", armod.t1, armod.t2, armod.nobs, armod.ncoeff, armod.dfd); #endif /* allocations for pass 2 */ if (qtotal > 0) { malags = malloc(qtotal * sizeof *malags); if (malags == NULL) { err = E_ALLOC; } else { for (i=0, pos=0; i<nq; i++) { malags[pos++] = i+1; } for (i=0; i<ainfo->Q; i++) { for (j=0; j<=nq; j++) { malags[pos++] = (i+1) * dset->pd + j; } } } } if (ptotal > 0 && !err) { arlags = malloc(ptotal * sizeof *arlags); if (arlags == NULL) { err = E_ALLOC; } else { for (i=0, pos=0; i<np; i++) { arlags[pos++] = i+1; } for (i=0; i<ainfo->P; i++) { for (j=0; j<=np; j++) { arlags[pos++] = (i+1) * dset->pd + j; } } } } if (!err) { pass2list = gretl_list_new(2 + nexo + ptotal + qtotal); if (pass2list == NULL) { err = E_ALLOC; } } /* handle error in pass2 allocations */ if (err) { goto bailout; } /* stick lagged residuals into temp dataset */ pos = pass1v; for (i=0; i<qtotal; i++) { sprintf(aset->varname[pos], "e_%d", malags[i]); for (t=0; t<ainfo->T; t++) { s = t - malags[i]; aset->Z[pos][t] = (s >= 0)? armod.uhat[s] : NADBL; } pos++; } /* compose pass 2 regression list */ for (i=1, pos=1; i<=nexo+2; i++) { pass2list[pos++] = pass1list[i]; } for (i=0; i<ptotal; i++) { /* FIXME? */ if (AR_included(ainfo,i)) { pass2list[pos++] = arlags[i] + nexo + 1; } } for (i=0; i<qtotal; i++) { /* FIXME? */ if (MA_included(ainfo,i)) { pass2list[pos++] = pass1v + i; } } /* now do pass2 */ clear_model(&armod); armod = lsq(pass2list, aset, OLS, OPT_A); if (armod.errcode) { err = armod.errcode; } else { #if AINIT_DEBUG PRN *modprn = gretl_print_new(GRETL_PRINT_STDERR, NULL); printmodel(&armod, aset, OPT_S, modprn); gretl_print_destroy(modprn); #endif err = hr_transcribe_coeffs(ainfo, &armod, coeff); if (!err && arma_exact_ml(ainfo) && ainfo->ifc && ainfo->nexo == 0) { transform_arma_const(coeff, ainfo); } } #if AINIT_DEBUG if (!err) { fprintf(stderr, "HR init:\n"); for (i=0; i<ainfo->nc; i++) { fprintf(stderr, "coeff[%d] = %g\n", i, coeff[i]); } } #endif bailout: free(pass1list); free(pass2list); free(arlags); free(malags); destroy_dataset(aset); clear_model(&armod); if (!err && prn != NULL) { pprintf(prn, "\n%s: %s\n\n", _("ARMA initialization"), _("Hannan-Rissanen method")); } return err; }
static int check_arima_list (arma_info *ainfo, const DATASET *dset, gretlopt opt) { int *list = ainfo->alist; int ypos = arma_has_seasonal(ainfo) ? 9 : 5; int armax = (list[0] > ypos); int hadconst = 0; int err = 0; if (list[1] < 0 || list[1] > MAX_ARMA_ORDER) { err = 1; } else if (list[2] < 0 || list[2] > MAX_ARIMA_DIFF) { err = 1; } else if (list[3] < 0 || list[3] > MAX_ARMA_ORDER) { err = 1; } if (!err) { ainfo->p = list[1]; ainfo->d = list[2]; ainfo->q = list[3]; } if (!err && arma_has_seasonal(ainfo)) { if (list[0] < 9) { err = 1; } else if (list[5] < 0 || list[5] > MAX_ARMA_ORDER) { err = 1; } else if (list[6] < 0 || list[6] > MAX_ARIMA_DIFF) { err = 1; } else if (list[7] < 0 || list[7] > MAX_ARMA_ORDER) { err = 1; } } if (!err && arma_has_seasonal(ainfo)) { ainfo->P = list[5]; ainfo->D = list[6]; ainfo->Q = list[7]; } /* now that we have p and q we can check for masked lags */ if (!err) { err = arma_make_masks(ainfo); } /* If there's an explicit constant in the list here, we'll remove it, since it is added implicitly later. But if we're supplied with OPT_N (meaning: no intercept) we'll flag this by setting ifc = 0. Also, if the user gave an armax list (specifying regressors) we'll respect the absence of a constant from that list by setting ifc = 0. */ if (!err) { if (armax) { hadconst = arma_remove_const(ainfo, dset); } if ((opt & OPT_N) || (armax && !hadconst)) { ; } else { ainfo->ifc = 1; } } if (err) { gretl_errmsg_set(_("Error in arma command")); } else { ainfo->nexo = list[0] - ypos; ainfo->nc = count_arma_coeffs(ainfo); ainfo->yno = list[ypos]; if (ainfo->nexo > 0) { err = arma_add_xlist(ainfo, ypos); } } return err; }