int main(int argc, char **argv)
{
int i;
int errors;
DataSet *train_set;
DataSet *test_set;
Network *adultnn = create_network(14);
double e;
double acc;
Class predicted, desired;
// training
train_set = read_dataset("adult.train");
if (train_set == NULL) {
fprintf(stderr, "Error reading training set\n");
exit(1);
}
add_layer(adultnn, 28); // hidden layer
add_layer(adultnn, 2); // output layer
initialize_weights(adultnn, SEED);
print_network_structure(adultnn);
printf("Training network with %d epochs...\n", EPOCHS);
e = batch_train(adultnn, train_set, LEARNING_RATE, EPOCHS,
sigmoid, dsigmoid);
printf("Training finished, approximate final SSE: %f\n", e);
print_network_structure(adultnn);
// testing
test_set = read_dataset("adult.test");
if (test_set == NULL) {
fprintf(stderr, "Error reading test set\n");
exit(1);
}
errors = 0;
printf("Testing with %d cases...\n", test_set->n_cases);
for (i = 0; i < test_set->n_cases; ++i) {
predicted = predict_class(adultnn, test_set->input[i]);
desired = output_to_class(test_set->output[i]);
if (predicted != desired)
++errors;
printf("Case %d | predicted: %s, desired: %s, outputs: %4.3f %4.3f \n", i,
class_to_string(predicted), class_to_string(desired),
adultnn->output_layer->y[0], adultnn->output_layer->y[1]);
}
acc = 100.0 - (100.0 * errors / test_set->n_cases);
printf("Testing accuracy: %f\n", acc);
printf("Total classificarion errors: %d\n", errors);
destroy_dataset(train_set);
destroy_dataset(test_set);
return 0;
}
int main (void)
{
DATASET *dset;
PRN *prn;
int err;
libgretl_init();
dset = datainfo_new();
prn = gretl_print_new(GRETL_PRINT_STDOUT, NULL);
/* note: PREFIX is defined in the Makefile */
err = gretl_read_native_data(PREFIX "/share/gretl/data/misc/ects_nls.gdt",
dset);
if (err) {
errmsg(err, prn);
exit(EXIT_FAILURE);
}
err = nls_estimate(dset, prn);
if (err) {
errmsg(err, prn);
}
destroy_dataset(dset);
gretl_print_destroy(prn);
libgretl_cleanup();
return 0;
}
int matrix_freq_driver (const int *list,
int *graph,
gretlopt opt,
PRN *prn)
{
gretl_matrix *m = NULL;
DATASET *mdset = NULL;
const char *mname;
int err = 0;
if (list[0] != 1) {
return E_PARSE;
}
mname = get_optval_string(FREQ, OPT_X);
if (mname != NULL) {
m = get_matrix_by_name(mname);
}
if (gretl_is_null_matrix(m)) {
err = E_DATA;
} else {
mdset = gretl_dataset_from_matrix(m, list, OPT_B, &err);
}
if (!err) {
err = freqdist(1, mdset, graph, opt, prn);
}
destroy_dataset(mdset);
return err;
}
static void xlsx_info_free (xlsx_info *xinfo)
{
if (xinfo != NULL) {
strings_array_free(xinfo->sheetnames, xinfo->n_sheets);
strings_array_free(xinfo->filenames, xinfo->n_sheets);
strings_array_free(xinfo->strings, xinfo->n_strings);
destroy_dataset(xinfo->dset);
}
}
static void irf_boot_free (irfboot *b)
{
if (b == NULL) {
return;
}
gretl_matrix_free(b->rE);
gretl_matrix_free(b->Xt);
gretl_matrix_free(b->Yt);
gretl_matrix_free(b->Et);
gretl_matrix_free(b->rtmp);
gretl_matrix_free(b->ctmp);
gretl_matrix_free(b->resp);
gretl_matrix_free(b->C0);
if (b->dset != NULL) {
destroy_dataset(b->dset);
}
free(b->sample);
free(b);
}
int main (int argc, char *argv[])
{
#ifdef WIN32
char *callname = argv[0];
#endif
char linecopy[MAXLINE];
DATASET *dset = NULL;
MODEL *model = NULL;
ExecState state;
char *line = NULL;
int quiet = 0;
int makepkg = 0;
int load_datafile = 1;
char filearg[MAXLEN];
char runfile[MAXLEN];
double scriptval = NADBL;
CMD cmd;
PRN *prn = NULL;
PRN *cmdprn = NULL;
int err = 0;
#ifdef G_OS_WIN32
win32_set_gretldir(callname);
#endif
nls_init();
#ifdef HAVE_READLINE
rl_bind_key(0x18, ctrl_x);
#endif
dset = datainfo_new();
if (dset == NULL) {
noalloc();
}
if (argc < 2) {
load_datafile = 0;
} else {
gretlopt opt = 0;
err = parse_options(&argc, &argv, &opt, &scriptval, filearg);
if (!err && (opt & (OPT_DBOPEN | OPT_WEBDB))) {
/* catch GUI-only options */
err = E_BADOPT;
}
if (err) {
/* bad option */
usage(1);
} else if (opt & (OPT_HELP | OPT_VERSION)) {
/* we'll exit in these cases */
if (opt & OPT_HELP) {
usage(0);
} else {
logo(0);
exit(EXIT_SUCCESS);
}
}
if (opt & (OPT_BATCH | OPT_RUNIT | OPT_MAKEPKG)) {
if (*filearg == '\0') {
/* we're missing a filename argument */
usage(1);
} else {
/* record argument (not a datafile) */
strcpy(runfile, filearg);
load_datafile = 0;
if (opt & OPT_BATCH) {
batch = 1;
} else if (opt & OPT_MAKEPKG) {
batch = 1;
makepkg = 1;
} else {
runit = 1;
}
}
} else if (*filearg == '\0') {
load_datafile = 0;
}
if (opt & OPT_QUIET) {
quiet = 1;
}
if (opt & OPT_ENGLISH) {
force_language(LANG_C);
}
}
libgretl_init();
logo(quiet);
if (!quiet) {
session_time(NULL);
}
prn = gretl_print_new(GRETL_PRINT_STDOUT, &err);
if (err) {
noalloc();
}
line = malloc(MAXLINE);
if (line == NULL) {
noalloc();
}
#ifdef WIN32
win32_cli_read_rc(callname);
#else
cli_read_rc();
#endif /* WIN32 */
if (!batch) {
strcpy(cmdfile, gretl_workdir());
strcat(cmdfile, "session.inp");
cmdprn = gretl_print_new_with_filename(cmdfile, &err);
if (err) {
errmsg(err, prn);
return EXIT_FAILURE;
}
}
if (load_datafile) {
handle_datafile(filearg, runfile, dset, prn, cmdprn);
}
/* allocate memory for model */
model = allocate_working_model();
if (model == NULL) {
noalloc();
}
gretl_cmd_init(&cmd);
gretl_exec_state_init(&state, 0, line, &cmd, model, prn);
set_debug_read_func(get_interactive_line);
/* print list of variables */
if (data_status) {
varlist(dset, prn);
}
if (!na(scriptval)) {
/* define "scriptopt" */
gretl_scalar_add("scriptopt", scriptval);
}
/* misc. interactive-mode setup */
if (!batch) {
check_help_file();
fb = stdin;
push_input_file(fb);
if (!runit && !data_status) {
fputs(_("Type \"open filename\" to open a data set\n"), stdout);
}
}
#ifdef HAVE_READLINE
initialize_readline();
#endif
if (batch || runit) {
/* re-initialize: will be incremented by "run" cmd */
runit = 0;
if (makepkg) {
set_gretl_echo(0);
}
if (strchr(runfile, ' ')) {
sprintf(line, "run \"%s\"", runfile);
} else {
sprintf(line, "run %s", runfile);
}
err = cli_exec_line(&state, dset, cmdprn);
if (err && fb == NULL) {
exit(EXIT_FAILURE);
}
}
*linecopy = '\0';
/* main command loop */
while (cmd.ci != QUIT && fb != NULL && !xout) {
if (err && gretl_error_is_fatal()) {
gretl_abort(linecopy);
}
if (gretl_execute_loop()) {
if (gretl_loop_exec(&state, dset, NULL)) {
return 1;
}
} else {
err = cli_get_input_line(&state);
if (err) {
errmsg(err, prn);
break;
}
}
if (!state.in_comment) {
if (cmd.context == FOREIGN || cmd.context == MPI ||
gretl_compiling_python(line)) {
tailstrip(line);
} else {
err = maybe_get_input_line_continuation(line);
if (err) {
errmsg(err, prn);
break;
}
}
}
strcpy(linecopy, line);
tailstrip(linecopy);
err = cli_exec_line(&state, dset, cmdprn);
} /* end of get commands loop */
if (!err) {
err = gretl_if_state_check(0);
if (err) {
errmsg(err, prn);
}
}
if (makepkg && !err) {
switch_ext(filearg, runfile, "gfn");
sprintf(line, "makepkg %s\n", filearg);
cli_exec_line(&state, dset, cmdprn);
}
/* leak check -- try explicitly freeing all memory allocated */
destroy_working_model(model);
destroy_dataset(dset);
if (fb != stdin && fb != NULL) {
fclose(fb);
}
free(line);
gretl_print_destroy(prn);
gretl_cmd_free(&cmd);
libgretl_cleanup();
return 0;
}
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;
}
int arma_by_ls (const double *coeff, const DATASET *dset,
arma_info *ainfo, MODEL *pmod)
{
PRN *prn = ainfo->prn;
int *list = ainfo->alist;
int nmixed = ainfo->np * ainfo->P;
int ptotal = ainfo->np + ainfo->P + nmixed;
int av = ptotal + ainfo->nexo + 2;
DATASET *aset = NULL;
int *arlist = NULL;
int nonlin = 0;
aset = create_auxiliary_dataset(av, ainfo->T, 0);
if (aset == NULL) {
return E_ALLOC;
}
if (ptotal > 0 && nmixed > 0) {
/* we'll have to use NLS */
nonlin = 1;
} else {
/* OLS: need regression list */
arlist = make_ar_ols_list(ainfo, av);
}
/* build temporary dataset */
arma_init_build_dataset(ainfo, ptotal, 0, list,
dset, aset, nonlin);
if (nonlin) {
pmod->errcode = arma_get_nls_model(pmod, ainfo, 0, coeff, aset,
prn);
} else {
*pmod = lsq(arlist, aset, OLS, OPT_A | OPT_Z);
}
/* clean up */
free(arlist);
destroy_dataset(aset);
if (!pmod->errcode && pmod->full_n < dset->n) {
/* the model series are short */
double *uhat = malloc(dset->n * sizeof *uhat);
double *yhat = malloc(dset->n * sizeof *yhat);
int s, t;
if (uhat == NULL || yhat == NULL) {
free(uhat);
free(yhat);
pmod->errcode = E_ALLOC;
} else {
for (t=0; t<dset->n; t++) {
uhat[t] = yhat[t] = NADBL;
}
t = ainfo->t1;
for (s=0; s<pmod->full_n; s++, t++) {
uhat[t] = pmod->uhat[s];
yhat[t] = pmod->yhat[s];
}
free(pmod->uhat);
pmod->uhat = uhat;
free(pmod->yhat);
pmod->yhat = yhat;
}
}
return pmod->errcode;
}
int ar_arma_init (double *coeff, const DATASET *dset,
arma_info *ainfo, MODEL *pmod)
{
PRN *prn = ainfo->prn;
int *list = ainfo->alist;
int nmixed = ainfo->np * ainfo->P;
int ptotal = ainfo->np + ainfo->P + nmixed;
int av = ptotal + ainfo->nexo + 2;
DATASET *aset = NULL;
int *arlist = NULL;
MODEL armod;
int narmax, nonlin = 0;
int i, err = 0;
#if AINIT_DEBUG
fprintf(stderr, "ar_arma_init: dset->t1=%d, dset->t2=%d (dset->n=%d);\n"
" ainfo->t1=%d, ainfo->t2=%d, ",
dset->t1, dset->t2, dset->n, ainfo->t1, ainfo->t2);
fprintf(stderr, "nmixed = %d, ptotal = %d, ifc = %d, nexo = %d\n",
nmixed, ptotal, ainfo->ifc, ainfo->nexo);
#endif
if (ptotal == 0 && ainfo->nexo == 0 && !ainfo->ifc) {
/* special case of pure MA model */
for (i=0; i<ainfo->nq + ainfo->Q; i++) {
coeff[i] = 0.0001;
}
pprintf(ainfo->prn, "\n%s: %s\n\n", _("ARMA initialization"),
_("small MA values"));
return 0;
}
gretl_model_init(&armod, dset);
narmax = arma_exact_ml(ainfo) ? ainfo->nexo : 0;
if (narmax > 0 && ptotal > 0) {
/* ARMAX-induced lags of exog vars */
av += ainfo->nexo * ptotal;
}
if (arma_exact_ml(ainfo) && ainfo->ifc) {
maybe_set_yscale(ainfo);
}
aset = create_auxiliary_dataset(av, ainfo->fullT, 0);
if (aset == NULL) {
return E_ALLOC;
}
if (ptotal > 0 && (narmax > 0 || nmixed > 0)) {
/* we'll have to use NLS */
nonlin = 1;
} else {
/* OLS: need regression list */
arlist = make_ar_ols_list(ainfo, av);
}
/* build temporary dataset, dset -> aset */
arma_init_build_dataset(ainfo, ptotal, narmax, list,
dset, aset, nonlin);
if (nonlin) {
PRN *dprn = NULL;
#if AINIT_DEBUG
fprintf(stderr, "arma:_init_by_ls: doing NLS\n");
dprn = prn;
#endif
err = arma_get_nls_model(&armod, ainfo, narmax, NULL, aset,
dprn);
} else {
#if AINIT_DEBUG
printlist(arlist, "'arlist' in ar_arma_init (OLS)");
#endif
armod = lsq(arlist, aset, OLS, OPT_A | OPT_Z);
err = armod.errcode;
}
#if AINIT_DEBUG
if (!err) {
pputs(prn, "\n*** armod, in ar_arma_init\n");
printmodel(&armod, aset, OPT_NONE, prn);
} else {
fprintf(stderr, "LS init: armod.errcode = %d\n", err);
}
#endif
if (!err) {
arma_init_transcribe_coeffs(ainfo, &armod, coeff);
}
/* handle the case where we need to translate from an
estimate of the regression constant to the
unconditional mean of y_t
*/
if (!err && arma_exact_ml(ainfo) && ainfo->ifc &&
(!nonlin || ainfo->nexo == 0)) {
transform_arma_const(coeff, ainfo);
}
if (!err && prn != NULL) {
if (nonlin) {
pprintf(prn, "\n%s: %s\n\n", _("ARMA initialization"),
_("using nonlinear AR model"));
} else {
pprintf(prn, "\n%s: %s\n\n", _("ARMA initialization"),
_("using linear AR model"));
}
}
/* clean up */
clear_model(&armod);
free(arlist);
destroy_dataset(aset);
return err;
}
int gnumeric_get_data (const char *fname, int *list, char *sheetname,
DATASET *dset, gretlopt opt, PRN *prn)
{
int gui = (opt & OPT_G);
wbook gbook;
wbook *book = &gbook;
wsheet gsheet;
wsheet *sheet = &gsheet;
int sheetnum = -1;
int obscol = 0;
DATASET *newset;
int err = 0;
newset = datainfo_new();
if (newset == NULL) {
pputs(prn, _("Out of memory\n"));
return 1;
}
wsheet_init(sheet);
gretl_push_c_numeric_locale();
if (wbook_get_info(fname, list, sheetname, book, prn)) {
pputs(prn, _("Failed to get workbook info"));
err = 1;
goto getout;
}
wbook_print_info(book);
if (book->nsheets == 0) {
pputs(prn, _("No worksheets found"));
err = 1;
goto getout;
}
if (gui) {
if (book->nsheets > 1) {
wsheet_menu(book, 1);
sheetnum = book->selected;
} else {
wsheet_menu(book, 0);
sheetnum = 0;
}
} else {
err = wbook_check_params(book);
if (err) {
gretl_errmsg_set(_("Invalid argument for worksheet import"));
} else if (book->selected >= 0) {
sheetnum = book->selected;
} else {
sheetnum = 0;
}
}
if (book->selected == -1) {
/* canceled */
err = -1;
}
if (!err && sheetnum >= 0) {
fprintf(stderr, "Getting data...\n");
err = wsheet_setup(sheet, book, sheetnum);
if (!err) {
err = wsheet_get_data(fname, sheet, &obscol, prn);
if (err) {
fprintf(stderr, "wsheet_get_data returned %d\n", err);
} else {
wsheet_print_info(sheet);
book->flags |= sheet->flags;
}
}
}
if (err) {
goto getout;
} else {
int r0 = 1; /* the first data row */
int i, j, t;
int ts_markers = 0;
int merge = (dset->Z != NULL);
char **ts_S = NULL;
int blank_cols = 0;
int missvals = 0;
int pd = 0;
if (obscol) {
book_set_obs_labels(book);
if (sheet->text_cols == 0) {
sheet->text_cols = 1;
}
} else if (sheet->text_cols > 0) {
/* string-valued variable? */
fprintf(stderr, "Problem: sheet->text_cols = %d\n", sheet->text_cols);
}
if (sheet->colheads == 0) {
book_set_auto_varnames(book);
r0 = 0;
}
if (book_numeric_dates(book)) {
fputs("found calendar dates in first imported column\n", stderr);
} else if (obscol) {
fprintf(stderr, "found label strings in first imported column (text_cols = %d)\n",
sheet->text_cols);
} else if (sheet->text_cols > 0) {
fputs("found string-valued variable in first imported column?\n", stderr);
} else {
fputs("check for label strings in first imported column: not found\n", stderr);
}
newset->n = sheet->maxrow - sheet->row_offset;
if (!sheet->colheads) {
pputs(prn, _("it seems there are no variable names\n"));
newset->n += 1;
}
if (book_numeric_dates(book) || obscol) {
pd = importer_dates_check(sheet->label + r0, &book->flags,
newset, prn, &err);
if (pd > 0) {
/* got time-series info from dates/labels */
sheet_time_series_setup(sheet, book, newset, pd);
ts_markers = newset->markers;
ts_S = newset->S;
} else if (!book_numeric_dates(book)) {
if (labels_are_index(sheet->label, newset->n)) {
/* trash the labels */
book_unset_obs_labels(book);
}
}
}
newset->v = sheet->maxcol + 2 - sheet->col_offset - sheet->text_cols;
fprintf(stderr, "newset->v = %d, newset->n = %d\n",
newset->v, newset->n);
/* create import dataset */
err = worksheet_start_dataset(newset);
if (err) {
goto getout;
}
if (book_time_series(book)) {
newset->markers = ts_markers;
newset->S = ts_S;
} else {
dataset_obs_info_default(newset);
}
j = 1;
for (i=1; i<newset->v; i++) {
int s = (sheet->colheads)? 1 : 0;
int k = i - 1 + sheet->text_cols;
double zkt;
if (column_is_blank(sheet, k, newset->n)) {
blank_cols++;
continue;
}
if (sheet->colheads && *sheet->varname[k] != '\0') {
strcpy(newset->varname[j], sheet->varname[k]);
} else {
sprintf(newset->varname[j], "v%d", j);
}
for (t=0; t<newset->n; t++) {
zkt = sheet->Z[k][s++];
if (zkt == -999 || zkt == -9999) {
newset->Z[j][t] = NADBL;
} else {
newset->Z[j][t] = zkt;
}
if (na(newset->Z[j][t])) {
missvals = 1;
}
}
j++;
}
if (blank_cols > 0) {
fprintf(stderr, "Dropping %d apparently blank column(s)\n",
blank_cols);
dataset_drop_last_variables(newset, blank_cols);
}
if (missvals) {
pputs(prn, _("Warning: there were missing values\n"));
}
if (fix_varname_duplicates(newset)) {
pputs(prn, _("warning: some variable names were duplicated\n"));
}
if (book_obs_labels(book) && wsheet_labels_complete(sheet)) {
int offset = (sheet->colheads)? 1 : 0;
dataset_allocate_obs_markers(newset);
if (newset->S != NULL) {
for (t=0; t<newset->n; t++) {
strcpy(newset->S[t], sheet->label[t+offset]);
}
}
}
if (book->flags & BOOK_DATA_REVERSED) {
reverse_data(newset, prn);
}
if (!err && !dataset_is_time_series(newset) && newset->S != NULL) {
/* we didn't time series info above, but it's possible
the observation strings carry such info
*/
import_ts_check(newset);
}
err = merge_or_replace_data(dset, &newset, opt, prn);
if (!err && !merge) {
dataset_add_import_info(dset, fname, GRETL_GNUMERIC);
}
if (!err && gui) {
wbook_record_params(book, list);
}
}
getout:
wbook_free(book);
wsheet_free(sheet);
gretl_pop_c_numeric_locale();
if (err && newset != NULL) {
destroy_dataset(newset);
}
return err;
}
int matrix_command_driver (int ci,
const int *list,
const char *param,
const DATASET *dset,
gretlopt opt,
PRN *prn)
{
gretl_matrix *m = NULL;
DATASET *mdset = NULL;
int *collist = NULL;
const char *mname;
int err = 0;
mname = get_optval_string(ci, OPT_X);
if (mname != NULL) {
m = get_matrix_by_name(mname);
}
if (gretl_is_null_matrix(m)) {
err = E_DATA;
} else if (ci == SCATTERS) {
/* note: this is a special case, for now */
return matrix_scatters(m, list, dset, opt);
} else if (list != NULL && list[0] == 0) {
/* use all columns of the matrix */
mdset = gretl_dataset_from_matrix(m, NULL, OPT_B, &err);
} else if (list != NULL && list[0] == 1 && ci == SUMMARY) {
/* summary stats for a single specified column */
mdset = gretl_dataset_from_matrix(m, list, OPT_B | OPT_N, &err);
} else {
/* note that a NULL list is OK here */
mdset = gretl_dataset_from_matrix(m, list, OPT_B, &err);
}
if (!err) {
dataset_set_matrix_name(mdset, mname);
collist = gretl_consecutive_list_new(1, mdset->v - 1);
if (collist == NULL) {
err = E_ALLOC;
}
}
if (!err) {
opt &= ~OPT_X;
if (ci == BXPLOT) {
err = boxplots(collist, param, mdset, opt);
} else if (ci == GNUPLOT) {
err = gnuplot(collist, param, mdset, opt);
} else if (ci == SUMMARY) {
err = list_summary(collist, 0, mdset, opt, prn);
} else {
err = E_DATA;
}
}
destroy_dataset(mdset);
free(collist);
return err;
}
int main (void)
{
DATASET *dataset; /* pointer to dataset struct */
int *list; /* list of regressors etc. */
MODEL *model; /* pointer to model struct */
PRN *prn; /* pointer to struct for printing */
int model_count = 0; /* keep a tally of models estimated */
int i; /* index variable */
/* the first data series to load */
double z1[] = {
199.9, 228, 235, 285, 239, 293, 285,
365, 295, 290, 385, 505, 425, 415
};
/* and the second series */
double z2[] = {
1065, 1254, 1300, 1577, 1600, 1750, 1800,
1870, 1935, 1948, 2254, 2600, 2800, 3000
};
/* basic initialization of library */
libgretl_init();
prn = gretl_print_new(GRETL_PRINT_STDOUT, NULL); /* simple printing */
/* allocate the dataset struct: the parameters are the number of
variables (here 3, allowing for the constant in position 0),
the number of observations on each variable (here 14), and
a 0/1 flag indicating whether we want to supply "case marker"
strings for the observations (here we don't).
*/
dataset = create_new_dataset(3, 14, 0);
if (dataset == NULL) noalloc();
/* copy in the names of the variables (starting at [1]
because [0] refers to the constant) */
strcpy(dataset->varname[1], "price");
strcpy(dataset->varname[2], "sqft");
/* Fill in the data array, starting at variable 1. Note that
this array may be a superset of the data actually used in
the regression equation. Note that dataset->n records the
number of observations.
*/
for (i=0; i<dataset->n; i++) {
dset_set_data(dataset, 1, i, z1[i]);
dset_set_data(dataset, 2, i, z2[i]);
}
/* Set up the "list", which is fed to the regression function.
The first element of list represents the length of the list
vector itself, counting from zero. The second entry is the ID
number of the dependent variable (i.e. its place in the data
set Z) counting from one (zero being reserved for the
constant). The third entry (and there can be more) is the ID
number of the first independent variable.
*/
list = gretl_list_new(3); /* number of terms will be 3 */
list[1] = 1; /* the dependent variable is the one with ID# 1 */
list[2] = 0; /* we include a constant (ID# 0) */
list[3] = 2; /* the independent variable has ID# 2 */
/* Now we call the lsq function from libgretl to get least squares
estimates and associated statistics. */
model = gretl_model_new();
if (model == NULL) noalloc();
*model = lsq(list, /* regressand and regressors */
dataset, /* the dataset */
OLS, /* use Ordinary Least Squares */
OPT_NONE /* no special options */
);
/* Handle case where lsq bombed */
if (model->errcode) {
printf("model->errcode: %d\n", model->errcode);
printf("error message: %s\n", gretl_errmsg_get());
return 1;
}
/* Otherwise give this model an ID number for reference */
model->ID = ++model_count;
/* and print the regression results */
printmodel(model, dataset, OPT_NONE, prn);
/* memory management check -- try explicitly freeing all allocated
memory */
gretl_model_free(model);
free(list);
destroy_dataset(dataset);
gretl_print_destroy(prn);
libgretl_cleanup();
return 0;
}
int wf1_get_data (const char *fname, DATASET *dset,
gretlopt opt, PRN *prn)
{
FILE *fp;
DATASET *newset = NULL;
unsigned offset;
int nvread, ftype;
int err = 0;
fp = gretl_fopen(fname, "rb");
if (fp == NULL) {
return E_FOPEN;
}
ftype = wf1_check_file_type(fp);
if (ftype < 0) {
fclose(fp);
pputs(prn, "This file does not seem to be an EViews workfile\n");
return E_DATA;
}
if (ftype == 1) {
pputs(prn, "EViews 7+ file: expect problems!\n");
}
newset = datainfo_new();
if (newset == NULL) {
pputs(prn, _("Out of memory\n"));
fclose(fp);
return E_ALLOC;
}
err = parse_wf1_header(fp, ftype, newset, &offset);
if (err) {
pputs(prn, _("Error reading workfile header\n"));
free_datainfo(newset);
fclose(fp);
return err;
}
err = start_new_Z(newset, 0);
if (err) {
pputs(prn, _("Out of memory\n"));
free_datainfo(newset);
fclose(fp);
return E_ALLOC;
}
err = read_wf1_variables(fp, ftype, offset, newset, &nvread, prn);
if (err) {
destroy_dataset(newset);
} else {
int merge = (dset->Z != NULL);
int nvtarg = newset->v - 1;
if (nvread < nvtarg) {
dataset_drop_last_variables(newset, nvtarg - nvread);
}
if (fix_varname_duplicates(newset)) {
pputs(prn, _("warning: some variable names were duplicated\n"));
}
err = merge_or_replace_data(dset, &newset, opt, prn);
if (!err && !merge) {
dataset_add_import_info(dset, fname, GRETL_WF1);
}
}
fclose(fp);
return err;
}
